diff options
Diffstat (limited to 'src/mesa/drivers/dri')
165 files changed, 10425 insertions, 7485 deletions
diff --git a/src/mesa/drivers/dri/Makefile.template b/src/mesa/drivers/dri/Makefile.template index a00018cafa..4ecddbc048 100644 --- a/src/mesa/drivers/dri/Makefile.template +++ b/src/mesa/drivers/dri/Makefile.template @@ -86,11 +86,12 @@ subdirs: symlinks: -depend: $(C_SOURCES) $(ASM_SOURCES) $(SYMLINKS) +depend: $(C_SOURCES) $(CXX_SOURCES) $(ASM_SOURCES) $(SYMLINKS) @ echo "running $(MKDEP)" @ rm -f depend @ touch depend - @ $(MKDEP) $(MKDEP_OPTIONS) $(DRIVER_DEFINES) $(INCLUDES) $(C_SOURCES) \ + @ $(MKDEP) $(MKDEP_OPTIONS) $(DRIVER_DEFINES) $(INCLUDES) \ + $(C_SOURCES) $(CXX_SOURCES) \ $(ASM_SOURCES) > /dev/null 2>/dev/null diff --git a/src/mesa/drivers/dri/common/utils.c b/src/mesa/drivers/dri/common/utils.c index c195c4fd8f..42be77fd7c 100644 --- a/src/mesa/drivers/dri/common/utils.c +++ b/src/mesa/drivers/dri/common/utils.c @@ -738,12 +738,18 @@ static const struct { unsigned int attrib, offset; } attribMap[] = { #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0])) + +/** + * Return the value of a configuration attribute. The attribute is + * indicated by the index. + */ static int driGetConfigAttribIndex(const __DRIconfig *config, unsigned int index, unsigned int *value) { switch (attribMap[index].attrib) { case __DRI_ATTRIB_RENDER_TYPE: + /* no support for color index mode */ *value = __DRI_ATTRIB_RGBA_BIT; break; case __DRI_ATTRIB_CONFIG_CAVEAT: @@ -755,13 +761,16 @@ driGetConfigAttribIndex(const __DRIconfig *config, *value = 0; break; case __DRI_ATTRIB_SWAP_METHOD: + /* XXX no return value??? */ break; case __DRI_ATTRIB_FLOAT_MODE: + /* this field is not int-sized */ *value = config->modes.floatMode; break; default: + /* any other int-sized field */ *value = *(unsigned int *) ((char *) &config->modes + attribMap[index].offset); @@ -771,6 +780,13 @@ driGetConfigAttribIndex(const __DRIconfig *config, return GL_TRUE; } + +/** + * Get the value of a configuration attribute. + * \param attrib the attribute (one of the _DRI_ATTRIB_x tokens) + * \param value returns the attribute's value + * \return 1 for success, 0 for failure + */ int driGetConfigAttrib(const __DRIconfig *config, unsigned int attrib, unsigned int *value) @@ -784,6 +800,14 @@ driGetConfigAttrib(const __DRIconfig *config, return GL_FALSE; } + +/** + * Get a configuration attribute name and value, given an index. + * \param index which field of the __DRIconfig to query + * \param attrib returns the attribute name (one of the _DRI_ATTRIB_x tokens) + * \param value returns the attribute's value + * \return 1 for success, 0 for failure + */ int driIndexConfigAttrib(const __DRIconfig *config, int index, unsigned int *attrib, unsigned int *value) diff --git a/src/mesa/drivers/dri/common/xmlpool/Makefile b/src/mesa/drivers/dri/common/xmlpool/Makefile index 62ec919ea6..b71629e9f1 100644 --- a/src/mesa/drivers/dri/common/xmlpool/Makefile +++ b/src/mesa/drivers/dri/common/xmlpool/Makefile @@ -62,7 +62,7 @@ clean: # Default target options.h options.h: t_options.h mo - python gen_xmlpool.py $(LANGS) > options.h + $(PYTHON2) $(PYTHON_FLAGS) gen_xmlpool.py $(LANGS) > options.h # Update .mo files from the corresponding .po files. mo: diff --git a/src/mesa/drivers/dri/i915/intel_structs.h b/src/mesa/drivers/dri/i915/intel_structs.h deleted file mode 100644 index 522e3bd92c..0000000000 --- a/src/mesa/drivers/dri/i915/intel_structs.h +++ /dev/null @@ -1,132 +0,0 @@ -#ifndef INTEL_STRUCTS_H -#define INTEL_STRUCTS_H - -struct br0 { - GLuint length:8; - GLuint pad0:3; - GLuint dst_tiled:1; - GLuint pad1:8; - GLuint write_rgb:1; - GLuint write_alpha:1; - GLuint opcode:7; - GLuint client:3; -}; - - -struct br13 { - GLint dest_pitch:16; - GLuint rop:8; - GLuint color_depth:2; - GLuint pad1:3; - GLuint mono_source_transparency:1; - GLuint clipping_enable:1; - GLuint pad0:1; -}; - - - -/* This is an attempt to move some of the 2D interaction in this - * driver to using structs for packets rather than a bunch of #defines - * and dwords. - */ -struct xy_color_blit { - struct br0 br0; - struct br13 br13; - - struct { - GLuint dest_x1:16; - GLuint dest_y1:16; - } dw2; - - struct { - GLuint dest_x2:16; - GLuint dest_y2:16; - } dw3; - - GLuint dest_base_addr; - GLuint color; -}; - -struct xy_src_copy_blit { - struct br0 br0; - struct br13 br13; - - struct { - GLuint dest_x1:16; - GLuint dest_y1:16; - } dw2; - - struct { - GLuint dest_x2:16; - GLuint dest_y2:16; - } dw3; - - GLuint dest_base_addr; - - struct { - GLuint src_x1:16; - GLuint src_y1:16; - } dw5; - - struct { - GLint src_pitch:16; - GLuint pad:16; - } dw6; - - GLuint src_base_addr; -}; - -struct xy_setup_blit { - struct br0 br0; - struct br13 br13; - - struct { - GLuint clip_x1:16; - GLuint clip_y1:16; - } dw2; - - struct { - GLuint clip_x2:16; - GLuint clip_y2:16; - } dw3; - - GLuint dest_base_addr; - GLuint background_color; - GLuint foreground_color; - GLuint pattern_base_addr; -}; - - -struct xy_text_immediate_blit { - struct { - GLuint length:8; - GLuint pad2:3; - GLuint dst_tiled:1; - GLuint pad1:4; - GLuint byte_packed:1; - GLuint pad0:5; - GLuint opcode:7; - GLuint client:3; - } dw0; - - struct { - GLuint dest_x1:16; - GLuint dest_y1:16; - } dw1; - - struct { - GLuint dest_x2:16; - GLuint dest_y2:16; - } dw2; - - /* Src bitmap data follows as inline dwords. - */ -}; - - -#define CLIENT_2D 0x2 -#define OPCODE_XY_SETUP_BLT 0x1 -#define OPCODE_XY_COLOR_BLT 0x50 -#define OPCODE_XY_TEXT_IMMEDIATE_BLT 0x31 - -#endif diff --git a/src/mesa/drivers/dri/i965/brw_cc.c b/src/mesa/drivers/dri/i965/brw_cc.c index 00418760da..a8369b07c3 100644 --- a/src/mesa/drivers/dri/i965/brw_cc.c +++ b/src/mesa/drivers/dri/i965/brw_cc.c @@ -204,7 +204,7 @@ static void upload_cc_unit(struct brw_context *brw) cc.cc2.depth_write_enable = ctx->Depth.Mask; } - if (intel->stats_wm || (INTEL_DEBUG & DEBUG_STATS)) + if (intel->stats_wm || unlikely(INTEL_DEBUG & DEBUG_STATS)) cc.cc5.statistics_enable = 1; /* CACHE_NEW_CC_VP */ diff --git a/src/mesa/drivers/dri/i965/brw_clip.c b/src/mesa/drivers/dri/i965/brw_clip.c index 15e60bf3ce..1be165cc9a 100644 --- a/src/mesa/drivers/dri/i965/brw_clip.c +++ b/src/mesa/drivers/dri/i965/brw_clip.c @@ -133,13 +133,13 @@ static void compile_clip_prog( struct brw_context *brw, */ program = brw_get_program(&c.func, &program_size); - if (INTEL_DEBUG & DEBUG_CLIP) { + if (unlikely(INTEL_DEBUG & DEBUG_CLIP)) { printf("clip:\n"); for (i = 0; i < program_size / sizeof(struct brw_instruction); i++) brw_disasm(stdout, &((struct brw_instruction *)program)[i], intel->gen); printf("\n"); - } + } /* Upload */ diff --git a/src/mesa/drivers/dri/i965/brw_clip_state.c b/src/mesa/drivers/dri/i965/brw_clip_state.c index 885167da90..60fd5fa7d9 100644 --- a/src/mesa/drivers/dri/i965/brw_clip_state.c +++ b/src/mesa/drivers/dri/i965/brw_clip_state.c @@ -114,10 +114,10 @@ clip_unit_create_from_key(struct brw_context *brw, clip.thread4.max_threads = 1 - 1; } - if (INTEL_DEBUG & DEBUG_SINGLE_THREAD) + if (unlikely(INTEL_DEBUG & DEBUG_SINGLE_THREAD)) clip.thread4.max_threads = 0; - if (INTEL_DEBUG & DEBUG_STATS) + if (unlikely(INTEL_DEBUG & DEBUG_STATS)) clip.thread4.stats_enable = 1; clip.clip5.userclip_enable_flags = 0x7f; diff --git a/src/mesa/drivers/dri/i965/brw_context.c b/src/mesa/drivers/dri/i965/brw_context.c index 3c4ae8a7a4..cb0a8b96c9 100644 --- a/src/mesa/drivers/dri/i965/brw_context.c +++ b/src/mesa/drivers/dri/i965/brw_context.c @@ -124,7 +124,7 @@ GLboolean brwCreateContext( int api, (i == MESA_SHADER_FRAGMENT); if (intel->gen == 6) - ctx->ShaderCompilerOptions[i].EmitNoIfs = GL_TRUE; + ctx->ShaderCompilerOptions[i].EmitNoIfs = (i == MESA_SHADER_VERTEX); } ctx->Const.VertexProgram.MaxNativeInstructions = (16 * 1024); diff --git a/src/mesa/drivers/dri/i965/brw_context.h b/src/mesa/drivers/dri/i965/brw_context.h index f205c07a72..335339515a 100644 --- a/src/mesa/drivers/dri/i965/brw_context.h +++ b/src/mesa/drivers/dri/i965/brw_context.h @@ -173,8 +173,6 @@ struct brw_fragment_program { GLuint id; /**< serial no. to identify frag progs, never re-used */ GLboolean isGLSL; /**< really, any IF/LOOP/CONT/BREAK instructions */ - GLboolean use_const_buffer; - /** for debugging, which texture units are referenced */ GLbitfield tex_units_used; }; @@ -190,6 +188,13 @@ struct brw_shader_program { struct gl_shader_program base; }; +enum param_conversion { + PARAM_NO_CONVERT, + PARAM_CONVERT_F2I, + PARAM_CONVERT_F2U, + PARAM_CONVERT_F2B, +}; + /* Data about a particular attempt to compile a program. Note that * there can be many of these, each in a different GL state * corresponding to a different brw_wm_prog_key struct, with different @@ -204,12 +209,16 @@ struct brw_wm_prog_data { GLuint total_scratch; GLuint nr_params; /**< number of float params/constants */ + GLuint nr_pull_params; GLboolean error; /* Pointer to tracked values (only valid once * _mesa_load_state_parameters has been called at runtime). */ - const GLfloat *param[BRW_MAX_CURBE]; + const float *param[MAX_UNIFORMS * 4]; /* should be: BRW_MAX_CURBE */ + enum param_conversion param_convert[MAX_UNIFORMS * 4]; + const float *pull_param[MAX_UNIFORMS * 4]; + enum param_conversion pull_param_convert[MAX_UNIFORMS * 4]; }; struct brw_sf_prog_data { @@ -800,6 +809,35 @@ brw_fragment_program_const(const struct gl_fragment_program *p) return (const struct brw_fragment_program *) p; } +static inline +float convert_param(enum param_conversion conversion, float param) +{ + union { + float f; + uint32_t u; + int32_t i; + } fi; + + switch (conversion) { + case PARAM_NO_CONVERT: + return param; + case PARAM_CONVERT_F2I: + fi.i = param; + return fi.f; + case PARAM_CONVERT_F2U: + fi.u = param; + return fi.f; + case PARAM_CONVERT_F2B: + if (param != 0.0) + fi.i = 1; + else + fi.i = 0; + return fi.f; + default: + return param; + } +} + GLboolean brw_do_cubemap_normalize(struct exec_list *instructions); #endif diff --git a/src/mesa/drivers/dri/i965/brw_curbe.c b/src/mesa/drivers/dri/i965/brw_curbe.c index 9ce0d8decd..7b823eb201 100644 --- a/src/mesa/drivers/dri/i965/brw_curbe.c +++ b/src/mesa/drivers/dri/i965/brw_curbe.c @@ -199,8 +199,10 @@ static void prepare_constant_buffer(struct brw_context *brw) GLuint offset = brw->curbe.wm_start * 16; /* copy float constants */ - for (i = 0; i < brw->wm.prog_data->nr_params; i++) - buf[offset + i] = *brw->wm.prog_data->param[i]; + for (i = 0; i < brw->wm.prog_data->nr_params; i++) { + buf[offset + i] = convert_param(brw->wm.prog_data->param_convert[i], + *brw->wm.prog_data->param[i]); + } } diff --git a/src/mesa/drivers/dri/i965/brw_defines.h b/src/mesa/drivers/dri/i965/brw_defines.h index 9633c95ff5..239586a036 100644 --- a/src/mesa/drivers/dri/i965/brw_defines.h +++ b/src/mesa/drivers/dri/i965/brw_defines.h @@ -551,6 +551,7 @@ #define BRW_OPCODE_POP 47 #define BRW_OPCODE_WAIT 48 #define BRW_OPCODE_SEND 49 +#define BRW_OPCODE_SENDC 50 #define BRW_OPCODE_MATH 56 #define BRW_OPCODE_ADD 64 #define BRW_OPCODE_MUL 65 @@ -929,6 +930,11 @@ #define CMD_3D_CLIP_STATE 0x7812 /* GEN6+ */ /* DW1 */ # define GEN6_CLIP_STATISTICS_ENABLE (1 << 10) +/** + * Just does cheap culling based on the clip distance. Bits must be + * disjoint with USER_CLIP_CLIP_DISTANCE bits. + */ +# define GEN6_USER_CLIP_CULL_DISTANCES_SHIFT 0 /* DW2 */ # define GEN6_CLIP_ENABLE (1 << 31) # define GEN6_CLIP_API_OGL (0 << 30) @@ -936,6 +942,8 @@ # define GEN6_CLIP_XY_TEST (1 << 28) # define GEN6_CLIP_Z_TEST (1 << 27) # define GEN6_CLIP_GB_TEST (1 << 26) +/** 8-bit field of which user clip distances to clip aganist. */ +# define GEN6_USER_CLIP_CLIP_DISTANCES_SHIFT 16 # define GEN6_CLIP_MODE_NORMAL (0 << 13) # define GEN6_CLIP_MODE_REJECT_ALL (3 << 13) # define GEN6_CLIP_MODE_ACCEPT_ALL (4 << 13) diff --git a/src/mesa/drivers/dri/i965/brw_disasm.c b/src/mesa/drivers/dri/i965/brw_disasm.c index 12b8f2e467..962c04128b 100644 --- a/src/mesa/drivers/dri/i965/brw_disasm.c +++ b/src/mesa/drivers/dri/i965/brw_disasm.c @@ -72,6 +72,7 @@ struct { [BRW_OPCODE_CMPN] = { .name = "cmpn", .nsrc = 2, .ndst = 1 }, [BRW_OPCODE_SEND] = { .name = "send", .nsrc = 1, .ndst = 1 }, + [BRW_OPCODE_SENDC] = { .name = "sendc", .nsrc = 1, .ndst = 1 }, [BRW_OPCODE_NOP] = { .name = "nop", .nsrc = 0, .ndst = 0 }, [BRW_OPCODE_JMPI] = { .name = "jmpi", .nsrc = 1, .ndst = 0 }, [BRW_OPCODE_IF] = { .name = "if", .nsrc = 2, .ndst = 0 }, @@ -460,6 +461,9 @@ static int reg (FILE *file, GLuint _reg_file, GLuint _reg_nr) case BRW_ARF_ACCUMULATOR: format (file, "acc%d", _reg_nr & 0x0f); break; + case BRW_ARF_FLAG: + format (file, "f%d", _reg_nr & 0x0f); + break; case BRW_ARF_MASK: format (file, "mask%d", _reg_nr & 0x0f); break; @@ -876,7 +880,8 @@ int brw_disasm (FILE *file, struct brw_instruction *inst, int gen) string (file, " "); err |= control (file, "function", math_function, inst->header.destreg__conditionalmod, NULL); - } else if (inst->header.opcode != BRW_OPCODE_SEND) + } else if (inst->header.opcode != BRW_OPCODE_SEND && + inst->header.opcode != BRW_OPCODE_SENDC) err |= control (file, "conditional modifier", conditional_modifier, inst->header.destreg__conditionalmod, NULL); @@ -907,7 +912,8 @@ int brw_disasm (FILE *file, struct brw_instruction *inst, int gen) err |= src1 (file, inst); } - if (inst->header.opcode == BRW_OPCODE_SEND) { + if (inst->header.opcode == BRW_OPCODE_SEND || + inst->header.opcode == BRW_OPCODE_SENDC) { int target; if (gen >= 6) @@ -1070,7 +1076,8 @@ int brw_disasm (FILE *file, struct brw_instruction *inst, int gen) err |= control (file, "thread control", thread_ctrl, inst->header.thread_control, &space); if (gen >= 6) err |= control (file, "acc write control", accwr, inst->header.acc_wr_control, &space); - if (inst->header.opcode == BRW_OPCODE_SEND) + if (inst->header.opcode == BRW_OPCODE_SEND || + inst->header.opcode == BRW_OPCODE_SENDC) err |= control (file, "end of thread", end_of_thread, inst->bits3.generic.end_of_thread, &space); if (space) diff --git a/src/mesa/drivers/dri/i965/brw_draw.c b/src/mesa/drivers/dri/i965/brw_draw.c index 04bc8cb2db..a1f403ca4e 100644 --- a/src/mesa/drivers/dri/i965/brw_draw.c +++ b/src/mesa/drivers/dri/i965/brw_draw.c @@ -42,7 +42,7 @@ #include "intel_batchbuffer.h" -#define FILE_DEBUG_FLAG DEBUG_BATCH +#define FILE_DEBUG_FLAG DEBUG_PRIMS static GLuint prim_to_hw_prim[GL_POLYGON+1] = { _3DPRIM_POINTLIST, @@ -83,8 +83,7 @@ static GLuint brw_set_prim(struct brw_context *brw, struct gl_context *ctx = &brw->intel.ctx; GLenum mode = prim->mode; - if (INTEL_DEBUG & DEBUG_PRIMS) - printf("PRIM: %s\n", _mesa_lookup_enum_by_nr(prim->mode)); + DBG("PRIM: %s\n", _mesa_lookup_enum_by_nr(prim->mode)); /* Slight optimization to avoid the GS program when not needed: */ @@ -133,9 +132,8 @@ static void brw_emit_prim(struct brw_context *brw, struct brw_3d_primitive prim_packet; struct intel_context *intel = &brw->intel; - if (INTEL_DEBUG & DEBUG_PRIMS) - printf("PRIM: %s %d %d\n", _mesa_lookup_enum_by_nr(prim->mode), - prim->start, prim->count); + DBG("PRIM: %s %d %d\n", _mesa_lookup_enum_by_nr(prim->mode), + prim->start, prim->count); prim_packet.header.opcode = CMD_3D_PRIM; prim_packet.header.length = sizeof(prim_packet)/4 - 2; diff --git a/src/mesa/drivers/dri/i965/brw_draw_upload.c b/src/mesa/drivers/dri/i965/brw_draw_upload.c index c4654360d4..2cefe614dd 100644 --- a/src/mesa/drivers/dri/i965/brw_draw_upload.c +++ b/src/mesa/drivers/dri/i965/brw_draw_upload.c @@ -168,7 +168,7 @@ static GLuint byte_types_scale[5] = { static GLuint get_surface_type( GLenum type, GLuint size, GLenum format, GLboolean normalized ) { - if (INTEL_DEBUG & DEBUG_VERTS) + if (unlikely(INTEL_DEBUG & DEBUG_VERTS)) printf("type %s size %d normalized %d\n", _mesa_lookup_enum_by_nr(type), size, normalized); diff --git a/src/mesa/drivers/dri/i965/brw_eu.h b/src/mesa/drivers/dri/i965/brw_eu.h index 0e3ccfa46c..b4538e6e8a 100644 --- a/src/mesa/drivers/dri/i965/brw_eu.h +++ b/src/mesa/drivers/dri/i965/brw_eu.h @@ -900,14 +900,24 @@ void brw_math2(struct brw_compile *p, void brw_oword_block_read(struct brw_compile *p, struct brw_reg dest, struct brw_reg mrf, - int num_regs, - GLuint offset); + uint32_t offset, + uint32_t bind_table_index); -void brw_dp_READ_4( struct brw_compile *p, - struct brw_reg dest, - GLboolean relAddr, - GLuint location, - GLuint bind_table_index ); +void brw_oword_block_read_scratch(struct brw_compile *p, + struct brw_reg dest, + struct brw_reg mrf, + int num_regs, + GLuint offset); + +void brw_oword_block_write_scratch(struct brw_compile *p, + struct brw_reg mrf, + int num_regs, + GLuint offset); + +void brw_dword_scattered_read(struct brw_compile *p, + struct brw_reg dest, + struct brw_reg mrf, + uint32_t bind_table_index); void brw_dp_READ_4_vs( struct brw_compile *p, struct brw_reg dest, @@ -920,11 +930,6 @@ void brw_dp_READ_4_vs_relative(struct brw_compile *p, GLuint offset, GLuint bind_table_index); -void brw_oword_block_write(struct brw_compile *p, - struct brw_reg mrf, - int num_regs, - GLuint offset); - /* If/else/endif. Works by manipulating the execution flags on each * channel. */ diff --git a/src/mesa/drivers/dri/i965/brw_eu_emit.c b/src/mesa/drivers/dri/i965/brw_eu_emit.c index 6fbc39672f..9cb941dacf 100644 --- a/src/mesa/drivers/dri/i965/brw_eu_emit.c +++ b/src/mesa/drivers/dri/i965/brw_eu_emit.c @@ -496,20 +496,34 @@ static void brw_set_dp_write_message( struct brw_context *brw, } } -static void brw_set_dp_read_message( struct brw_context *brw, - struct brw_instruction *insn, - GLuint binding_table_index, - GLuint msg_control, - GLuint msg_type, - GLuint target_cache, - GLuint msg_length, - GLuint response_length, - GLuint end_of_thread ) +static void +brw_set_dp_read_message(struct brw_context *brw, + struct brw_instruction *insn, + GLuint binding_table_index, + GLuint msg_control, + GLuint msg_type, + GLuint target_cache, + GLuint msg_length, + GLuint response_length) { struct intel_context *intel = &brw->intel; brw_set_src1(insn, brw_imm_d(0)); - if (intel->gen == 5) { + if (intel->gen >= 6) { + insn->bits3.dp_render_cache.binding_table_index = binding_table_index; + insn->bits3.dp_render_cache.msg_control = msg_control; + insn->bits3.dp_render_cache.pixel_scoreboard_clear = 0; + insn->bits3.dp_render_cache.msg_type = msg_type; + insn->bits3.dp_render_cache.send_commit_msg = 0; + insn->bits3.dp_render_cache.header_present = 1; + insn->bits3.dp_render_cache.response_length = response_length; + insn->bits3.dp_render_cache.msg_length = msg_length; + insn->bits3.dp_render_cache.end_of_thread = 0; + insn->header.destreg__conditionalmod = BRW_MESSAGE_TARGET_DATAPORT_READ; + /* XXX really need below? */ + insn->bits2.send_gen5.sfid = BRW_MESSAGE_TARGET_DATAPORT_READ; + insn->bits2.send_gen5.end_of_thread = 0; + } else if (intel->gen == 5) { insn->bits3.dp_read_gen5.binding_table_index = binding_table_index; insn->bits3.dp_read_gen5.msg_control = msg_control; insn->bits3.dp_read_gen5.msg_type = msg_type; @@ -518,9 +532,9 @@ static void brw_set_dp_read_message( struct brw_context *brw, insn->bits3.dp_read_gen5.response_length = response_length; insn->bits3.dp_read_gen5.msg_length = msg_length; insn->bits3.dp_read_gen5.pad1 = 0; - insn->bits3.dp_read_gen5.end_of_thread = end_of_thread; + insn->bits3.dp_read_gen5.end_of_thread = 0; insn->bits2.send_gen5.sfid = BRW_MESSAGE_TARGET_DATAPORT_READ; - insn->bits2.send_gen5.end_of_thread = end_of_thread; + insn->bits2.send_gen5.end_of_thread = 0; } else { insn->bits3.dp_read.binding_table_index = binding_table_index; /*0:7*/ insn->bits3.dp_read.msg_control = msg_control; /*8:11*/ @@ -530,7 +544,7 @@ static void brw_set_dp_read_message( struct brw_context *brw, insn->bits3.dp_read.msg_length = msg_length; /*20:23*/ insn->bits3.dp_read.msg_target = BRW_MESSAGE_TARGET_DATAPORT_READ; /*24:27*/ insn->bits3.dp_read.pad1 = 0; /*28:30*/ - insn->bits3.dp_read.end_of_thread = end_of_thread; /*31*/ + insn->bits3.dp_read.end_of_thread = 0; /*31*/ } } @@ -955,7 +969,7 @@ void brw_ENDIF(struct brw_compile *p, brw_set_src0(insn, retype(brw_vec4_grf(0,0), BRW_REGISTER_TYPE_UD)); brw_set_src1(insn, brw_imm_d(0x0)); } else { - brw_set_dest(insn, retype(brw_vec4_grf(0,0), BRW_REGISTER_TYPE_W)); + brw_set_dest(insn, brw_imm_w(0)); brw_set_src0(insn, retype(brw_null_reg(), BRW_REGISTER_TYPE_D)); brw_set_src1(insn, retype(brw_null_reg(), BRW_REGISTER_TYPE_D)); } @@ -1359,10 +1373,10 @@ void brw_math_16( struct brw_compile *p, * The offset must be aligned to oword size (16 bytes). Used for * register spilling. */ -void brw_oword_block_write(struct brw_compile *p, - struct brw_reg mrf, - int num_regs, - GLuint offset) +void brw_oword_block_write_scratch(struct brw_compile *p, + struct brw_reg mrf, + int num_regs, + GLuint offset) { struct intel_context *intel = &p->brw->intel; uint32_t msg_control; @@ -1458,11 +1472,11 @@ void brw_oword_block_write(struct brw_compile *p, * spilling. */ void -brw_oword_block_read(struct brw_compile *p, - struct brw_reg dest, - struct brw_reg mrf, - int num_regs, - GLuint offset) +brw_oword_block_read_scratch(struct brw_compile *p, + struct brw_reg dest, + struct brw_reg mrf, + int num_regs, + GLuint offset) { uint32_t msg_control; int rlen; @@ -1512,69 +1526,108 @@ brw_oword_block_read(struct brw_compile *p, BRW_DATAPORT_READ_MESSAGE_OWORD_BLOCK_READ, /* msg_type */ 1, /* target cache (render/scratch) */ 1, /* msg_length */ - rlen, - 0); /* eot */ + rlen); } } - /** * Read a float[4] vector from the data port Data Cache (const buffer). * Location (in buffer) should be a multiple of 16. * Used for fetching shader constants. - * If relAddr is true, we'll do an indirect fetch using the address register. */ -void brw_dp_READ_4( struct brw_compile *p, - struct brw_reg dest, - GLboolean relAddr, - GLuint location, - GLuint bind_table_index ) +void brw_oword_block_read(struct brw_compile *p, + struct brw_reg dest, + struct brw_reg mrf, + uint32_t offset, + uint32_t bind_table_index) { - /* XXX: relAddr not implemented */ - GLuint msg_reg_nr = 1; - { - struct brw_reg b; - brw_push_insn_state(p); - brw_set_predicate_control(p, BRW_PREDICATE_NONE); - brw_set_compression_control(p, BRW_COMPRESSION_NONE); - brw_set_mask_control(p, BRW_MASK_DISABLE); + struct intel_context *intel = &p->brw->intel; - /* Setup MRF[1] with location/offset into const buffer */ - b = brw_message_reg(msg_reg_nr); - b = retype(b, BRW_REGISTER_TYPE_UD); - /* XXX I think we're setting all the dwords of MRF[1] to 'location'. - * when the docs say only dword[2] should be set. Hmmm. But it works. - */ - brw_MOV(p, b, brw_imm_ud(location)); - brw_pop_insn_state(p); - } + /* On newer hardware, offset is in units of owords. */ + if (intel->gen >= 6) + offset /= 16; - { - struct brw_instruction *insn = next_insn(p, BRW_OPCODE_SEND); - - insn->header.predicate_control = BRW_PREDICATE_NONE; - insn->header.compression_control = BRW_COMPRESSION_NONE; - insn->header.destreg__conditionalmod = msg_reg_nr; - insn->header.mask_control = BRW_MASK_DISABLE; - - /* cast dest to a uword[8] vector */ - dest = retype(vec8(dest), BRW_REGISTER_TYPE_UW); + mrf = retype(mrf, BRW_REGISTER_TYPE_UD); - brw_set_dest(insn, dest); - brw_set_src0(insn, brw_null_reg()); + brw_push_insn_state(p); + brw_set_predicate_control(p, BRW_PREDICATE_NONE); + brw_set_compression_control(p, BRW_COMPRESSION_NONE); + brw_set_mask_control(p, BRW_MASK_DISABLE); - brw_set_dp_read_message(p->brw, - insn, - bind_table_index, - 0, /* msg_control (0 means 1 Oword) */ - BRW_DATAPORT_READ_MESSAGE_OWORD_BLOCK_READ, /* msg_type */ - 0, /* source cache = data cache */ - 1, /* msg_length */ - 1, /* response_length (1 Oword) */ - 0); /* eot */ + brw_MOV(p, mrf, retype(brw_vec8_grf(0, 0), BRW_REGISTER_TYPE_UD)); + + /* set message header global offset field (reg 0, element 2) */ + brw_MOV(p, + retype(brw_vec1_reg(BRW_MESSAGE_REGISTER_FILE, + mrf.nr, + 2), BRW_REGISTER_TYPE_UD), + brw_imm_ud(offset)); + + struct brw_instruction *insn = next_insn(p, BRW_OPCODE_SEND); + insn->header.destreg__conditionalmod = mrf.nr; + + /* cast dest to a uword[8] vector */ + dest = retype(vec8(dest), BRW_REGISTER_TYPE_UW); + + brw_set_dest(insn, dest); + if (intel->gen >= 6) { + brw_set_src0(insn, mrf); + } else { + brw_set_src0(insn, brw_null_reg()); } + + brw_set_dp_read_message(p->brw, + insn, + bind_table_index, + BRW_DATAPORT_OWORD_BLOCK_1_OWORDLOW, + BRW_DATAPORT_READ_MESSAGE_OWORD_BLOCK_READ, + 0, /* source cache = data cache */ + 1, /* msg_length */ + 1); /* response_length (1 reg, 2 owords!) */ + + brw_pop_insn_state(p); } +/** + * Read a set of dwords from the data port Data Cache (const buffer). + * + * Location (in buffer) appears as UD offsets in the register after + * the provided mrf header reg. + */ +void brw_dword_scattered_read(struct brw_compile *p, + struct brw_reg dest, + struct brw_reg mrf, + uint32_t bind_table_index) +{ + mrf = retype(mrf, BRW_REGISTER_TYPE_UD); + + brw_push_insn_state(p); + brw_set_predicate_control(p, BRW_PREDICATE_NONE); + brw_set_compression_control(p, BRW_COMPRESSION_NONE); + brw_set_mask_control(p, BRW_MASK_DISABLE); + brw_MOV(p, mrf, retype(brw_vec8_grf(0, 0), BRW_REGISTER_TYPE_UD)); + brw_pop_insn_state(p); + + struct brw_instruction *insn = next_insn(p, BRW_OPCODE_SEND); + insn->header.destreg__conditionalmod = mrf.nr; + + /* cast dest to a uword[8] vector */ + dest = retype(vec8(dest), BRW_REGISTER_TYPE_UW); + + brw_set_dest(insn, dest); + brw_set_src0(insn, brw_null_reg()); + + brw_set_dp_read_message(p->brw, + insn, + bind_table_index, + BRW_DATAPORT_DWORD_SCATTERED_BLOCK_8DWORDS, + BRW_DATAPORT_READ_MESSAGE_DWORD_SCATTERED_READ, + 0, /* source cache = data cache */ + 2, /* msg_length */ + 1); /* response_length */ +} + + /** * Read float[4] constant(s) from VS constant buffer. @@ -1628,8 +1681,7 @@ void brw_dp_READ_4_vs(struct brw_compile *p, BRW_DATAPORT_READ_MESSAGE_OWORD_BLOCK_READ, /* msg_type */ 0, /* source cache = data cache */ 1, /* msg_length */ - 1, /* response_length (1 Oword) */ - 0); /* eot */ + 1); /* response_length (1 Oword) */ } /** @@ -1682,8 +1734,7 @@ void brw_dp_READ_4_vs_relative(struct brw_compile *p, msg_type, 0, /* source cache = data cache */ 2, /* msg_length */ - 1, /* response_length */ - 0); /* eot */ + 1); /* response_length */ } @@ -1703,8 +1754,13 @@ void brw_fb_WRITE(struct brw_compile *p, GLuint msg_control, msg_type; GLboolean header_present = GL_TRUE; - insn = next_insn(p, BRW_OPCODE_SEND); - insn->header.predicate_control = 0; /* XXX */ + if (intel->gen >= 6 && binding_table_index == 0) { + insn = next_insn(p, BRW_OPCODE_SENDC); + } else { + insn = next_insn(p, BRW_OPCODE_SEND); + } + /* The execution mask is ignored for render target writes. */ + insn->header.predicate_control = 0; insn->header.compression_control = BRW_COMPRESSION_NONE; if (intel->gen >= 6) { diff --git a/src/mesa/drivers/dri/i965/brw_fs.cpp b/src/mesa/drivers/dri/i965/brw_fs.cpp index 174f622d59..edb02fabb2 100644 --- a/src/mesa/drivers/dri/i965/brw_fs.cpp +++ b/src/mesa/drivers/dri/i965/brw_fs.cpp @@ -89,8 +89,6 @@ brw_compile_shader(struct gl_context *ctx, struct gl_shader *shader) GLboolean brw_link_shader(struct gl_context *ctx, struct gl_shader_program *prog) { - struct intel_context *intel = intel_context(ctx); - struct brw_shader *shader = (struct brw_shader *)prog->_LinkedShaders[MESA_SHADER_FRAGMENT]; if (shader != NULL) { @@ -103,10 +101,12 @@ brw_link_shader(struct gl_context *ctx, struct gl_shader_program *prog) clone_ir_list(mem_ctx, shader->ir, shader->base.ir); do_mat_op_to_vec(shader->ir); - do_mod_to_fract(shader->ir); - do_div_to_mul_rcp(shader->ir); - do_sub_to_add_neg(shader->ir); - do_explog_to_explog2(shader->ir); + lower_instructions(shader->ir, + MOD_TO_FRACT | + DIV_TO_MUL_RCP | + SUB_TO_ADD_NEG | + EXP_TO_EXP2 | + LOG_TO_LOG2); do_lower_texture_projection(shader->ir); brw_do_cubemap_normalize(shader->ir); @@ -132,9 +132,7 @@ brw_link_shader(struct gl_context *ctx, struct gl_shader_program *prog) GL_TRUE, /* temp */ GL_TRUE /* uniform */ ) || progress; - if (intel->gen == 6) { - progress = do_if_to_cond_assign(shader->ir) || progress; - } + progress = lower_quadop_vector(shader->ir, false) || progress; } while (progress); validate_ir_tree(shader->ir); @@ -179,6 +177,46 @@ type_size(const struct glsl_type *type) } } +/** + * Returns how many MRFs an FS opcode will write over. + * + * Note that this is not the 0 or 1 implied writes in an actual gen + * instruction -- the FS opcodes often generate MOVs in addition. + */ +int +fs_visitor::implied_mrf_writes(fs_inst *inst) +{ + if (inst->mlen == 0) + return 0; + + switch (inst->opcode) { + case FS_OPCODE_RCP: + case FS_OPCODE_RSQ: + case FS_OPCODE_SQRT: + case FS_OPCODE_EXP2: + case FS_OPCODE_LOG2: + case FS_OPCODE_SIN: + case FS_OPCODE_COS: + return 1; + case FS_OPCODE_POW: + return 2; + case FS_OPCODE_TEX: + case FS_OPCODE_TXB: + case FS_OPCODE_TXL: + return 1; + case FS_OPCODE_FB_WRITE: + return 2; + case FS_OPCODE_PULL_CONSTANT_LOAD: + case FS_OPCODE_UNSPILL: + return 1; + case FS_OPCODE_SPILL: + return 2; + default: + assert(!"not reached"); + return inst->mlen; + } +} + int fs_visitor::virtual_grf_alloc(int size) { @@ -228,6 +266,7 @@ brw_type_for_base_type(const struct glsl_type *type) return BRW_REGISTER_TYPE_UD; case GLSL_TYPE_ARRAY: case GLSL_TYPE_STRUCT: + case GLSL_TYPE_SAMPLER: /* These should be overridden with the type of the member when * dereferenced into. BRW_REGISTER_TYPE_UD seems like a likely * way to trip up if we don't. @@ -286,7 +325,30 @@ fs_visitor::setup_uniform_values(int loc, const glsl_type *type) case GLSL_TYPE_BOOL: vec_values = fp->Base.Parameters->ParameterValues[loc]; for (unsigned int i = 0; i < type->vector_elements; i++) { - c->prog_data.param[c->prog_data.nr_params++] = &vec_values[i]; + unsigned int param = c->prog_data.nr_params++; + + assert(param < ARRAY_SIZE(c->prog_data.param)); + + switch (type->base_type) { + case GLSL_TYPE_FLOAT: + c->prog_data.param_convert[param] = PARAM_NO_CONVERT; + break; + case GLSL_TYPE_UINT: + c->prog_data.param_convert[param] = PARAM_CONVERT_F2U; + break; + case GLSL_TYPE_INT: + c->prog_data.param_convert[param] = PARAM_CONVERT_F2I; + break; + case GLSL_TYPE_BOOL: + c->prog_data.param_convert[param] = PARAM_CONVERT_F2B; + break; + default: + assert(!"not reached"); + c->prog_data.param_convert[param] = PARAM_NO_CONVERT; + break; + } + + c->prog_data.param[param] = &vec_values[i]; } return 1; @@ -370,6 +432,8 @@ fs_visitor::setup_builtin_uniform_values(ir_variable *ir) break; last_swiz = swiz; + c->prog_data.param_convert[c->prog_data.nr_params] = + PARAM_NO_CONVERT; c->prog_data.param[c->prog_data.nr_params++] = &vec_values[swiz]; } } @@ -383,6 +447,7 @@ fs_visitor::emit_fragcoord_interpolation(ir_variable *ir) fs_reg wpos = *reg; fs_reg neg_y = this->pixel_y; neg_y.negate = true; + bool flip = !ir->origin_upper_left ^ c->key.render_to_fbo; /* gl_FragCoord.x */ if (ir->pixel_center_integer) { @@ -393,13 +458,13 @@ fs_visitor::emit_fragcoord_interpolation(ir_variable *ir) wpos.reg_offset++; /* gl_FragCoord.y */ - if (ir->origin_upper_left && ir->pixel_center_integer) { + if (!flip && ir->pixel_center_integer) { emit(fs_inst(BRW_OPCODE_MOV, wpos, this->pixel_y)); } else { fs_reg pixel_y = this->pixel_y; float offset = (ir->pixel_center_integer ? 0.0 : 0.5); - if (!ir->origin_upper_left) { + if (flip) { pixel_y.negate = true; offset += c->key.drawable_height - 1.0; } @@ -624,6 +689,7 @@ fs_visitor::visit(ir_variable *ir) } reg = new(this->mem_ctx) fs_reg(UNIFORM, param_index); + reg->type = brw_type_for_base_type(ir->type); } if (!reg) @@ -678,6 +744,27 @@ fs_visitor::visit(ir_dereference_array *ir) } } +/* Instruction selection: Produce a MOV.sat instead of + * MIN(MAX(val, 0), 1) when possible. + */ +bool +fs_visitor::try_emit_saturate(ir_expression *ir) +{ + ir_rvalue *sat_val = ir->as_rvalue_to_saturate(); + + if (!sat_val) + return false; + + sat_val->accept(this); + fs_reg src = this->result; + + this->result = fs_reg(this, ir->type); + fs_inst *inst = emit(fs_inst(BRW_OPCODE_MOV, this->result, src)); + inst->saturate = true; + + return true; +} + void fs_visitor::visit(ir_expression *ir) { @@ -685,6 +772,11 @@ fs_visitor::visit(ir_expression *ir) fs_reg op[2], temp; fs_inst *inst; + assert(ir->get_num_operands() <= 2); + + if (try_emit_saturate(ir)) + return; + for (operand = 0; operand < ir->get_num_operands(); operand++) { ir->operands[operand]->accept(this); if (this->result.file == BAD_FILE) { @@ -755,9 +847,11 @@ fs_visitor::visit(ir_expression *ir) assert(!"not reached: should be handled by ir_explog_to_explog2"); break; case ir_unop_sin: + case ir_unop_sin_reduced: emit_math(FS_OPCODE_SIN, this->result, op[0]); break; case ir_unop_cos: + case ir_unop_cos_reduced: emit_math(FS_OPCODE_COS, this->result, op[0]); break; @@ -831,7 +925,6 @@ fs_visitor::visit(ir_expression *ir) break; case ir_binop_dot: - case ir_binop_cross: case ir_unop_any: assert(!"not reached: should be handled by brw_fs_channel_expressions"); break; @@ -900,12 +993,21 @@ fs_visitor::visit(ir_expression *ir) break; case ir_unop_bit_not: - case ir_unop_u2f: - case ir_binop_lshift: - case ir_binop_rshift: + inst = emit(fs_inst(BRW_OPCODE_NOT, this->result, op[0])); + break; case ir_binop_bit_and: + inst = emit(fs_inst(BRW_OPCODE_AND, this->result, op[0], op[1])); + break; case ir_binop_bit_xor: + inst = emit(fs_inst(BRW_OPCODE_XOR, this->result, op[0], op[1])); + break; case ir_binop_bit_or: + inst = emit(fs_inst(BRW_OPCODE_OR, this->result, op[0], op[1])); + break; + + case ir_unop_u2f: + case ir_binop_lshift: + case ir_binop_rshift: assert(!"GLSL 1.30 features unsupported"); break; } @@ -1185,7 +1287,7 @@ fs_visitor::visit(ir_texture *ir) assert(!ir->projector); sampler = _mesa_get_sampler_uniform_value(ir->sampler, - ctx->Shader.CurrentProgram, + ctx->Shader.CurrentFragmentProgram, &brw->fragment_program->Base); sampler = c->fp->program.Base.SamplerUnits[sampler]; @@ -1203,6 +1305,11 @@ fs_visitor::visit(ir_texture *ir) 0 }; + c->prog_data.param_convert[c->prog_data.nr_params] = + PARAM_NO_CONVERT; + c->prog_data.param_convert[c->prog_data.nr_params + 1] = + PARAM_NO_CONVERT; + fs_reg scale_x = fs_reg(UNIFORM, c->prog_data.nr_params); fs_reg scale_y = fs_reg(UNIFORM, c->prog_data.nr_params + 1); GLuint index = _mesa_add_state_reference(params, @@ -1349,6 +1456,7 @@ fs_visitor::emit_bool_to_cond_code(ir_rvalue *ir) fs_reg op[2]; fs_inst *inst; + assert(expr->get_num_operands() <= 2); for (unsigned int i = 0; i < expr->get_num_operands(); i++) { assert(expr->operands[i]->type->is_scalar()); @@ -1456,6 +1564,7 @@ fs_visitor::emit_if_gen6(ir_if *ir) fs_inst *inst; fs_reg temp; + assert(expr->get_num_operands() <= 2); for (unsigned int i = 0; i < expr->get_num_operands(); i++) { assert(expr->operands[i]->type->is_scalar()); @@ -1960,6 +2069,20 @@ fs_visitor::generate_fb_write(fs_inst *inst) brw_MOV(p, brw_message_reg(inst->base_mrf), brw_vec8_grf(0, 0)); + + if (inst->target > 0) { + /* Set the render target index for choosing BLEND_STATE. */ + brw_MOV(p, retype(brw_vec1_reg(BRW_MESSAGE_REGISTER_FILE, 0, 2), + BRW_REGISTER_TYPE_UD), + brw_imm_ud(inst->target)); + } + + /* Clear viewport index, render target array index. */ + brw_AND(p, retype(brw_vec1_reg(BRW_MESSAGE_REGISTER_FILE, 0, 0), + BRW_REGISTER_TYPE_UD), + retype(brw_vec1_grf(0, 0), BRW_REGISTER_TYPE_UD), + brw_imm_ud(0xf7ff)); + implied_header = brw_null_reg(); } else { implied_header = retype(brw_vec8_grf(0, 0), BRW_REGISTER_TYPE_UW); @@ -2204,22 +2327,53 @@ fs_visitor::generate_ddy(fs_inst *inst, struct brw_reg dst, struct brw_reg src) void fs_visitor::generate_discard_not(fs_inst *inst, struct brw_reg mask) { - brw_push_insn_state(p); - brw_set_mask_control(p, BRW_MASK_DISABLE); - brw_NOT(p, mask, brw_mask_reg(1)); /* IMASK */ - brw_pop_insn_state(p); + if (intel->gen >= 6) { + /* Gen6 no longer has the mask reg for us to just read the + * active channels from. However, cmp updates just the channels + * of the flag reg that are enabled, so we can get at the + * channel enables that way. In this step, make a reg of ones + * we'll compare to. + */ + brw_MOV(p, mask, brw_imm_ud(1)); + } else { + brw_push_insn_state(p); + brw_set_mask_control(p, BRW_MASK_DISABLE); + brw_NOT(p, mask, brw_mask_reg(1)); /* IMASK */ + brw_pop_insn_state(p); + } } void fs_visitor::generate_discard_and(fs_inst *inst, struct brw_reg mask) { - struct brw_reg g0 = retype(brw_vec1_grf(0, 0), BRW_REGISTER_TYPE_UW); - mask = brw_uw1_reg(mask.file, mask.nr, 0); + if (intel->gen >= 6) { + struct brw_reg f0 = brw_flag_reg(); + struct brw_reg g1 = retype(brw_vec1_grf(1, 7), BRW_REGISTER_TYPE_UW); + + brw_push_insn_state(p); + brw_set_mask_control(p, BRW_MASK_DISABLE); + brw_MOV(p, f0, brw_imm_uw(0xffff)); /* inactive channels undiscarded */ + brw_pop_insn_state(p); + + brw_CMP(p, retype(brw_null_reg(), BRW_REGISTER_TYPE_UD), + BRW_CONDITIONAL_Z, mask, brw_imm_ud(0)); /* active channels fail test */ + /* Undo CMP's whacking of predication*/ + brw_set_predicate_control(p, BRW_PREDICATE_NONE); + + brw_push_insn_state(p); + brw_set_mask_control(p, BRW_MASK_DISABLE); + brw_AND(p, g1, f0, g1); + brw_pop_insn_state(p); + } else { + struct brw_reg g0 = retype(brw_vec1_grf(0, 0), BRW_REGISTER_TYPE_UW); - brw_push_insn_state(p); - brw_set_mask_control(p, BRW_MASK_DISABLE); - brw_AND(p, g0, mask, g0); - brw_pop_insn_state(p); + mask = brw_uw1_reg(mask.file, mask.nr, 0); + + brw_push_insn_state(p); + brw_set_mask_control(p, BRW_MASK_DISABLE); + brw_AND(p, g0, mask, g0); + brw_pop_insn_state(p); + } } void @@ -2230,7 +2384,8 @@ fs_visitor::generate_spill(fs_inst *inst, struct brw_reg src) brw_MOV(p, retype(brw_message_reg(inst->base_mrf + 1), BRW_REGISTER_TYPE_UD), retype(src, BRW_REGISTER_TYPE_UD)); - brw_oword_block_write(p, brw_message_reg(inst->base_mrf), 1, inst->offset); + brw_oword_block_write_scratch(p, brw_message_reg(inst->base_mrf), 1, + inst->offset); } void @@ -2251,8 +2406,39 @@ fs_visitor::generate_unspill(fs_inst *inst, struct brw_reg dst) if (intel->gen == 4 && !intel->is_g4x) brw_MOV(p, brw_null_reg(), dst); - brw_oword_block_read(p, dst, brw_message_reg(inst->base_mrf), 1, - inst->offset); + brw_oword_block_read_scratch(p, dst, brw_message_reg(inst->base_mrf), 1, + inst->offset); + + if (intel->gen == 4 && !intel->is_g4x) { + /* gen4 errata: destination from a send can't be used as a + * destination until it's been read. Just read it so we don't + * have to worry. + */ + brw_MOV(p, brw_null_reg(), dst); + } +} + + +void +fs_visitor::generate_pull_constant_load(fs_inst *inst, struct brw_reg dst) +{ + assert(inst->mlen != 0); + + /* Clear any post destination dependencies that would be ignored by + * the block read. See the B-Spec for pre-gen5 send instruction. + * + * This could use a better solution, since texture sampling and + * math reads could potentially run into it as well -- anywhere + * that we have a SEND with a destination that is a register that + * was written but not read within the last N instructions (what's + * N? unsure). This is rare because of dead code elimination, but + * not impossible. + */ + if (intel->gen == 4 && !intel->is_g4x) + brw_MOV(p, brw_null_reg(), dst); + + brw_oword_block_read(p, dst, brw_message_reg(inst->base_mrf), + inst->offset, SURF_INDEX_FRAG_CONST_BUFFER); if (intel->gen == 4 && !intel->is_g4x) { /* gen4 errata: destination from a send can't be used as a @@ -2281,7 +2467,7 @@ fs_visitor::assign_curb_setup() constant_nr % 8); inst->src[i].file = FIXED_HW_REG; - inst->src[i].fixed_hw_reg = brw_reg; + inst->src[i].fixed_hw_reg = retype(brw_reg, inst->src[i].type); } } } @@ -2406,6 +2592,7 @@ fs_visitor::split_virtual_grfs() for (int j = 2; j < this->virtual_grf_sizes[i]; j++) { int reg = virtual_grf_alloc(1); assert(reg == new_virtual_grf[i] + j - 1); + (void) reg; } this->virtual_grf_sizes[i] = 1; } @@ -2433,6 +2620,68 @@ fs_visitor::split_virtual_grfs() } } +/** + * Choose accesses from the UNIFORM file to demote to using the pull + * constant buffer. + * + * We allow a fragment shader to have more than the specified minimum + * maximum number of fragment shader uniform components (64). If + * there are too many of these, they'd fill up all of register space. + * So, this will push some of them out to the pull constant buffer and + * update the program to load them. + */ +void +fs_visitor::setup_pull_constants() +{ + /* Only allow 16 registers (128 uniform components) as push constants. */ + unsigned int max_uniform_components = 16 * 8; + if (c->prog_data.nr_params <= max_uniform_components) + return; + + /* Just demote the end of the list. We could probably do better + * here, demoting things that are rarely used in the program first. + */ + int pull_uniform_base = max_uniform_components; + int pull_uniform_count = c->prog_data.nr_params - pull_uniform_base; + + foreach_iter(exec_list_iterator, iter, this->instructions) { + fs_inst *inst = (fs_inst *)iter.get(); + + for (int i = 0; i < 3; i++) { + if (inst->src[i].file != UNIFORM) + continue; + + int uniform_nr = inst->src[i].hw_reg + inst->src[i].reg_offset; + if (uniform_nr < pull_uniform_base) + continue; + + fs_reg dst = fs_reg(this, glsl_type::float_type); + fs_inst *pull = new(mem_ctx) fs_inst(FS_OPCODE_PULL_CONSTANT_LOAD, + dst); + pull->offset = ((uniform_nr - pull_uniform_base) * 4) & ~15; + pull->ir = inst->ir; + pull->annotation = inst->annotation; + pull->base_mrf = 14; + pull->mlen = 1; + + inst->insert_before(pull); + + inst->src[i].file = GRF; + inst->src[i].reg = dst.reg; + inst->src[i].reg_offset = 0; + inst->src[i].smear = (uniform_nr - pull_uniform_base) & 3; + } + } + + for (int i = 0; i < pull_uniform_count; i++) { + c->prog_data.pull_param[i] = c->prog_data.param[pull_uniform_base + i]; + c->prog_data.pull_param_convert[i] = + c->prog_data.param_convert[pull_uniform_base + i]; + } + c->prog_data.nr_params -= pull_uniform_count; + c->prog_data.nr_pull_params = pull_uniform_count; +} + void fs_visitor::calculate_live_intervals() { @@ -2597,6 +2846,7 @@ fs_visitor::propagate_constants() } break; case BRW_OPCODE_CMP: + case BRW_OPCODE_SEL: if (i == 1) { scan_inst->src[i] = inst->src[0]; progress = true; @@ -2625,26 +2875,17 @@ bool fs_visitor::dead_code_eliminate() { bool progress = false; - int num_vars = this->virtual_grf_next; - bool dead[num_vars]; - - for (int i = 0; i < num_vars; i++) { - dead[i] = this->virtual_grf_def[i] >= this->virtual_grf_use[i]; - - if (dead[i]) { - /* Mark off its interval so it won't interfere with anything. */ - this->virtual_grf_def[i] = -1; - this->virtual_grf_use[i] = -1; - } - } + int pc = 0; foreach_iter(exec_list_iterator, iter, this->instructions) { fs_inst *inst = (fs_inst *)iter.get(); - if (inst->dst.file == GRF && dead[inst->dst.reg]) { + if (inst->dst.file == GRF && this->virtual_grf_use[inst->dst.reg] <= pc) { inst->remove(); progress = true; } + + pc++; } return progress; @@ -2721,6 +2962,7 @@ fs_visitor::register_coalesce() scan_inst->src[i].reg_offset = inst->src[0].reg_offset; scan_inst->src[i].abs |= inst->src[0].abs; scan_inst->src[i].negate ^= inst->src[0].negate; + scan_inst->src[i].smear = inst->src[0].smear; } } } @@ -2749,7 +2991,7 @@ fs_visitor::compute_to_mrf() inst->predicated || inst->dst.file != MRF || inst->src[0].file != GRF || inst->dst.type != inst->src[0].type || - inst->src[0].abs || inst->src[0].negate) + inst->src[0].abs || inst->src[0].negate || inst->src[0].smear != -1) continue; /* Can't compute-to-MRF this GRF if someone else was going to @@ -2761,11 +3003,60 @@ fs_visitor::compute_to_mrf() /* Found a move of a GRF to a MRF. Let's see if we can go * rewrite the thing that made this GRF to write into the MRF. */ - bool found = false; fs_inst *scan_inst; for (scan_inst = (fs_inst *)inst->prev; scan_inst->prev != NULL; scan_inst = (fs_inst *)scan_inst->prev) { + if (scan_inst->dst.file == GRF && + scan_inst->dst.reg == inst->src[0].reg) { + /* Found the last thing to write our reg we want to turn + * into a compute-to-MRF. + */ + + if (scan_inst->opcode == FS_OPCODE_TEX) { + /* texturing writes several continuous regs, so we can't + * compute-to-mrf that. + */ + break; + } + + /* If it's predicated, it (probably) didn't populate all + * the channels. + */ + if (scan_inst->predicated) + break; + + /* SEND instructions can't have MRF as a destination. */ + if (scan_inst->mlen) + break; + + if (intel->gen >= 6) { + /* gen6 math instructions must have the destination be + * GRF, so no compute-to-MRF for them. + */ + if (scan_inst->opcode == FS_OPCODE_RCP || + scan_inst->opcode == FS_OPCODE_RSQ || + scan_inst->opcode == FS_OPCODE_SQRT || + scan_inst->opcode == FS_OPCODE_EXP2 || + scan_inst->opcode == FS_OPCODE_LOG2 || + scan_inst->opcode == FS_OPCODE_SIN || + scan_inst->opcode == FS_OPCODE_COS || + scan_inst->opcode == FS_OPCODE_POW) { + break; + } + } + + if (scan_inst->dst.reg_offset == inst->src[0].reg_offset) { + /* Found the creator of our MRF's source value. */ + scan_inst->dst.file = MRF; + scan_inst->dst.hw_reg = inst->dst.hw_reg; + scan_inst->saturate |= inst->saturate; + inst->remove(); + progress = true; + } + break; + } + /* We don't handle flow control here. Most computation of * values that end up in MRFs are shortly before the MRF * write anyway. @@ -2799,71 +3090,88 @@ fs_visitor::compute_to_mrf() } if (scan_inst->mlen > 0) { - /* Found a SEND instruction, which will do some amount of - * implied write that may overwrite our MRF that we were - * hoping to compute-to-MRF somewhere above it. Nothing - * we have implied-writes more than 2 MRFs from base_mrf, - * though. + /* Found a SEND instruction, which means that there are + * live values in MRFs from base_mrf to base_mrf + + * scan_inst->mlen - 1. Don't go pushing our MRF write up + * above it. */ - int implied_write_len = MIN2(scan_inst->mlen, 2); if (inst->dst.hw_reg >= scan_inst->base_mrf && - inst->dst.hw_reg < scan_inst->base_mrf + implied_write_len) { + inst->dst.hw_reg < scan_inst->base_mrf + scan_inst->mlen) { break; } } + } + } - if (scan_inst->dst.file == GRF && - scan_inst->dst.reg == inst->src[0].reg) { - /* Found the last thing to write our reg we want to turn - * into a compute-to-MRF. - */ + return progress; +} - if (scan_inst->opcode == FS_OPCODE_TEX) { - /* texturing writes several continuous regs, so we can't - * compute-to-mrf that. - */ - break; - } +/** + * Walks through basic blocks, locking for repeated MRF writes and + * removing the later ones. + */ +bool +fs_visitor::remove_duplicate_mrf_writes() +{ + fs_inst *last_mrf_move[16]; + bool progress = false; - /* If it's predicated, it (probably) didn't populate all - * the channels. - */ - if (scan_inst->predicated) - break; + memset(last_mrf_move, 0, sizeof(last_mrf_move)); - /* SEND instructions can't have MRF as a destination. */ - if (scan_inst->mlen) - break; + foreach_iter(exec_list_iterator, iter, this->instructions) { + fs_inst *inst = (fs_inst *)iter.get(); - if (intel->gen >= 6) { - /* gen6 math instructions must have the destination be - * GRF, so no compute-to-MRF for them. - */ - if (scan_inst->opcode == FS_OPCODE_RCP || - scan_inst->opcode == FS_OPCODE_RSQ || - scan_inst->opcode == FS_OPCODE_SQRT || - scan_inst->opcode == FS_OPCODE_EXP2 || - scan_inst->opcode == FS_OPCODE_LOG2 || - scan_inst->opcode == FS_OPCODE_SIN || - scan_inst->opcode == FS_OPCODE_COS || - scan_inst->opcode == FS_OPCODE_POW) { - break; - } - } + switch (inst->opcode) { + case BRW_OPCODE_DO: + case BRW_OPCODE_WHILE: + case BRW_OPCODE_IF: + case BRW_OPCODE_ELSE: + case BRW_OPCODE_ENDIF: + memset(last_mrf_move, 0, sizeof(last_mrf_move)); + continue; + default: + break; + } - if (scan_inst->dst.reg_offset == inst->src[0].reg_offset) { - /* Found the creator of our MRF's source value. */ - found = true; - break; + if (inst->opcode == BRW_OPCODE_MOV && + inst->dst.file == MRF) { + fs_inst *prev_inst = last_mrf_move[inst->dst.hw_reg]; + if (prev_inst && inst->equals(prev_inst)) { + inst->remove(); + progress = true; + continue; + } + } + + /* Clear out the last-write records for MRFs that were overwritten. */ + if (inst->dst.file == MRF) { + last_mrf_move[inst->dst.hw_reg] = NULL; + } + + if (inst->mlen > 0) { + /* Found a SEND instruction, which will include two of fewer + * implied MRF writes. We could do better here. + */ + for (int i = 0; i < implied_mrf_writes(inst); i++) { + last_mrf_move[inst->base_mrf + i] = NULL; + } + } + + /* Clear out any MRF move records whose sources got overwritten. */ + if (inst->dst.file == GRF) { + for (unsigned int i = 0; i < Elements(last_mrf_move); i++) { + if (last_mrf_move[i] && + last_mrf_move[i]->src[0].reg == inst->dst.reg) { + last_mrf_move[i] = NULL; } } } - if (found) { - scan_inst->dst.file = MRF; - scan_inst->dst.hw_reg = inst->dst.hw_reg; - scan_inst->saturate |= inst->saturate; - inst->remove(); - progress = true; + + if (inst->opcode == BRW_OPCODE_MOV && + inst->dst.file == MRF && + inst->src[0].file == GRF && + !inst->predicated) { + last_mrf_move[inst->dst.hw_reg] = inst; } } @@ -2897,8 +3205,13 @@ static struct brw_reg brw_reg_from_fs_reg(fs_reg *reg) case GRF: case ARF: case MRF: - brw_reg = brw_vec8_reg(reg->file, - reg->hw_reg, 0); + if (reg->smear == -1) { + brw_reg = brw_vec8_reg(reg->file, + reg->hw_reg, 0); + } else { + brw_reg = brw_vec1_reg(reg->file, + reg->hw_reg, reg->smear); + } brw_reg = retype(brw_reg, reg->type); break; case IMM: @@ -2940,11 +3253,17 @@ static struct brw_reg brw_reg_from_fs_reg(fs_reg *reg) void fs_visitor::generate_code() { - unsigned int annotation_len = 0; int last_native_inst = 0; struct brw_instruction *if_stack[16], *loop_stack[16]; int if_stack_depth = 0, loop_stack_depth = 0; int if_depth_in_loop[16]; + const char *last_annotation_string = NULL; + ir_instruction *last_annotation_ir = NULL; + + if (unlikely(INTEL_DEBUG & DEBUG_WM)) { + printf("Native code for fragment shader %d:\n", + ctx->Shader.CurrentFragmentProgram->Name); + } if_depth_in_loop[loop_stack_depth] = 0; @@ -2953,6 +3272,22 @@ fs_visitor::generate_code() fs_inst *inst = (fs_inst *)iter.get(); struct brw_reg src[3], dst; + if (unlikely(INTEL_DEBUG & DEBUG_WM)) { + if (last_annotation_ir != inst->ir) { + last_annotation_ir = inst->ir; + if (last_annotation_ir) { + printf(" "); + last_annotation_ir->print(); + printf("\n"); + } + } + if (last_annotation_string != inst->annotation) { + last_annotation_string = inst->annotation; + if (last_annotation_string) + printf(" %s\n", last_annotation_string); + } + } + for (unsigned int i = 0; i < 3; i++) { src[i] = brw_reg_from_fs_reg(&inst->src[i]); } @@ -2960,6 +3295,7 @@ fs_visitor::generate_code() brw_set_conditionalmod(p, inst->conditional_mod); brw_set_predicate_control(p, inst->predicated); + brw_set_saturate(p, inst->saturate); switch (inst->opcode) { case BRW_OPCODE_MOV: @@ -3037,6 +3373,10 @@ fs_visitor::generate_code() break; case BRW_OPCODE_DO: + /* FINISHME: We need to write the loop instruction support still. */ + if (intel->gen >= 6) + this->fail = true; + loop_stack[loop_stack_depth++] = brw_DO(p, BRW_EXECUTE_8); if_depth_in_loop[loop_stack_depth] = 0; break; @@ -3114,6 +3454,10 @@ fs_visitor::generate_code() generate_unspill(inst, dst); break; + case FS_OPCODE_PULL_CONSTANT_LOAD: + generate_pull_constant_load(inst, dst); + break; + case FS_OPCODE_FB_WRITE: generate_fb_write(inst); break; @@ -3127,25 +3471,19 @@ fs_visitor::generate_code() this->fail = true; } - if (annotation_len < p->nr_insn) { - annotation_len *= 2; - if (annotation_len < 16) - annotation_len = 16; - - this->annotation_string = talloc_realloc(this->mem_ctx, - annotation_string, - const char *, - annotation_len); - this->annotation_ir = talloc_realloc(this->mem_ctx, - annotation_ir, - ir_instruction *, - annotation_len); + if (unlikely(INTEL_DEBUG & DEBUG_WM)) { + for (unsigned int i = last_native_inst; i < p->nr_insn; i++) { + if (0) { + printf("0x%08x 0x%08x 0x%08x 0x%08x ", + ((uint32_t *)&p->store[i])[3], + ((uint32_t *)&p->store[i])[2], + ((uint32_t *)&p->store[i])[1], + ((uint32_t *)&p->store[i])[0]); + } + brw_disasm(stdout, &p->store[i], intel->gen); + } } - for (unsigned int i = last_native_inst; i < p->nr_insn; i++) { - this->annotation_string[i] = inst->annotation; - this->annotation_ir[i] = inst->ir; - } last_native_inst = p->nr_insn; } } @@ -3153,10 +3491,9 @@ fs_visitor::generate_code() GLboolean brw_wm_fs_emit(struct brw_context *brw, struct brw_wm_compile *c) { - struct brw_compile *p = &c->func; struct intel_context *intel = &brw->intel; struct gl_context *ctx = &intel->ctx; - struct gl_shader_program *prog = ctx->Shader.CurrentProgram; + struct gl_shader_program *prog = ctx->Shader.CurrentFragmentProgram; if (!prog) return GL_FALSE; @@ -3174,7 +3511,7 @@ brw_wm_fs_emit(struct brw_context *brw, struct brw_wm_compile *c) */ c->dispatch_width = 8; - if (INTEL_DEBUG & DEBUG_WM) { + if (unlikely(INTEL_DEBUG & DEBUG_WM)) { printf("GLSL IR for native fragment shader %d:\n", prog->Name); _mesa_print_ir(shader->ir, NULL); printf("\n"); @@ -3205,6 +3542,7 @@ brw_wm_fs_emit(struct brw_context *brw, struct brw_wm_compile *c) v.emit_fb_writes(); v.split_virtual_grfs(); + v.setup_pull_constants(); v.assign_curb_setup(); v.assign_urb_setup(); @@ -3212,6 +3550,9 @@ brw_wm_fs_emit(struct brw_context *brw, struct brw_wm_compile *c) bool progress; do { progress = false; + + progress = v.remove_duplicate_mrf_writes() || progress; + v.calculate_live_intervals(); progress = v.propagate_constants() || progress; progress = v.register_coalesce() || progress; @@ -3248,37 +3589,6 @@ brw_wm_fs_emit(struct brw_context *brw, struct brw_wm_compile *c) if (v.fail) return GL_FALSE; - if (INTEL_DEBUG & DEBUG_WM) { - const char *last_annotation_string = NULL; - ir_instruction *last_annotation_ir = NULL; - - printf("Native code for fragment shader %d:\n", prog->Name); - for (unsigned int i = 0; i < p->nr_insn; i++) { - if (last_annotation_ir != v.annotation_ir[i]) { - last_annotation_ir = v.annotation_ir[i]; - if (last_annotation_ir) { - printf(" "); - last_annotation_ir->print(); - printf("\n"); - } - } - if (last_annotation_string != v.annotation_string[i]) { - last_annotation_string = v.annotation_string[i]; - if (last_annotation_string) - printf(" %s\n", last_annotation_string); - } - if (0) { - printf("0x%08x 0x%08x 0x%08x 0x%08x ", - ((uint32_t *)&p->store[i])[3], - ((uint32_t *)&p->store[i])[2], - ((uint32_t *)&p->store[i])[1], - ((uint32_t *)&p->store[i])[0]); - } - brw_disasm(stdout, &p->store[i], intel->gen); - } - printf("\n"); - } - c->prog_data.total_grf = v.grf_used; return GL_TRUE; diff --git a/src/mesa/drivers/dri/i965/brw_fs.h b/src/mesa/drivers/dri/i965/brw_fs.h index de7137a7db..de7b15312a 100644 --- a/src/mesa/drivers/dri/i965/brw_fs.h +++ b/src/mesa/drivers/dri/i965/brw_fs.h @@ -76,6 +76,7 @@ enum fs_opcodes { FS_OPCODE_DISCARD_AND, FS_OPCODE_SPILL, FS_OPCODE_UNSPILL, + FS_OPCODE_PULL_CONSTANT_LOAD, }; @@ -95,11 +96,9 @@ public: void init() { - this->reg = 0; - this->reg_offset = 0; - this->negate = 0; - this->abs = 0; + memset(this, 0, sizeof(*this)); this->hw_reg = -1; + this->smear = -1; } /** Generic unset register constructor. */ @@ -149,6 +148,21 @@ public: fs_reg(enum register_file file, int hw_reg, uint32_t type); fs_reg(class fs_visitor *v, const struct glsl_type *type); + bool equals(fs_reg *r) + { + return (file == r->file && + reg == r->reg && + reg_offset == r->reg_offset && + hw_reg == r->hw_reg && + type == r->type && + negate == r->negate && + abs == r->abs && + memcmp(&fixed_hw_reg, &r->fixed_hw_reg, + sizeof(fixed_hw_reg)) == 0 && + smear == r->smear && + imm.u == r->imm.u); + } + /** Register file: ARF, GRF, MRF, IMM. */ enum register_file file; /** virtual register number. 0 = fixed hw reg */ @@ -162,6 +176,7 @@ public: bool negate; bool abs; struct brw_reg fixed_hw_reg; + int smear; /* -1, or a channel of the reg to smear to all channels. */ /** Value for file == BRW_IMMMEDIATE_FILE */ union { @@ -171,6 +186,10 @@ public: } imm; }; +static const fs_reg reg_undef; +static const fs_reg reg_null_f(ARF, BRW_ARF_NULL, BRW_REGISTER_TYPE_F); +static const fs_reg reg_null_d(ARF, BRW_ARF_NULL, BRW_REGISTER_TYPE_D); + class fs_inst : public exec_node { public: /* Callers of this talloc-based new need not call delete. It's @@ -187,18 +206,14 @@ public: void init() { + memset(this, 0, sizeof(*this)); this->opcode = BRW_OPCODE_NOP; - this->saturate = false; this->conditional_mod = BRW_CONDITIONAL_NONE; - this->predicated = false; - this->sampler = 0; - this->target = 0; - this->eot = false; - this->header_present = false; - this->shadow_compare = false; - this->mlen = 0; - this->base_mrf = 0; - this->offset = 0; + + this->dst = reg_undef; + this->src[0] = reg_undef; + this->src[1] = reg_undef; + this->src[2] = reg_undef; } fs_inst() @@ -270,6 +285,26 @@ public: assert(src[2].reg_offset >= 0); } + bool equals(fs_inst *inst) + { + return (opcode == inst->opcode && + dst.equals(&inst->dst) && + src[0].equals(&inst->src[0]) && + src[1].equals(&inst->src[1]) && + src[2].equals(&inst->src[2]) && + saturate == inst->saturate && + predicated == inst->predicated && + conditional_mod == inst->conditional_mod && + mlen == inst->mlen && + base_mrf == inst->base_mrf && + sampler == inst->sampler && + target == inst->target && + eot == inst->eot && + header_present == inst->header_present && + shadow_compare == inst->shadow_compare && + offset == inst->offset); + } + int opcode; /* BRW_OPCODE_* or FS_OPCODE_* */ fs_reg dst; fs_reg src[3]; @@ -319,8 +354,6 @@ public: this->first_non_payload_grf = 0; this->current_annotation = NULL; - this->annotation_string = NULL; - this->annotation_ir = NULL; this->base_ir = NULL; this->virtual_grf_sizes = NULL; @@ -368,11 +401,13 @@ public: int choose_spill_reg(struct ra_graph *g); void spill_reg(int spill_reg); void split_virtual_grfs(); + void setup_pull_constants(); void calculate_live_intervals(); bool propagate_constants(); bool register_coalesce(); bool compute_to_mrf(); bool dead_code_eliminate(); + bool remove_duplicate_mrf_writes(); bool virtual_grf_interferes(int a, int b); void generate_code(); void generate_fb_write(fs_inst *inst); @@ -386,6 +421,7 @@ public: void generate_ddy(fs_inst *inst, struct brw_reg dst, struct brw_reg src); void generate_spill(fs_inst *inst, struct brw_reg src); void generate_unspill(fs_inst *inst, struct brw_reg dst); + void generate_pull_constant_load(fs_inst *inst, struct brw_reg dst); void emit_dummy_fs(); fs_reg *emit_fragcoord_interpolation(ir_variable *ir); @@ -397,6 +433,7 @@ public: fs_inst *emit_texture_gen5(ir_texture *ir, fs_reg dst, fs_reg coordinate); fs_inst *emit_math(fs_opcodes op, fs_reg dst, fs_reg src0); fs_inst *emit_math(fs_opcodes op, fs_reg dst, fs_reg src0, fs_reg src1); + bool try_emit_saturate(ir_expression *ir); void emit_bool_to_cond_code(ir_rvalue *condition); void emit_if_gen6(ir_if *ir); void emit_unspill(fs_inst *inst, fs_reg reg, uint32_t spill_offset); @@ -408,6 +445,7 @@ public: struct brw_reg interp_reg(int location, int channel); int setup_uniform_values(int loc, const glsl_type *type); void setup_builtin_uniform_values(ir_variable *ir); + int implied_mrf_writes(fs_inst *inst); struct brw_context *brw; const struct gl_fragment_program *fp; @@ -434,8 +472,6 @@ public: /** @{ debug annotation info */ const char *current_annotation; ir_instruction *base_ir; - const char **annotation_string; - ir_instruction **annotation_ir; /** @} */ bool fail; @@ -453,9 +489,5 @@ public: int grf_used; }; -static const fs_reg reg_undef; -static const fs_reg reg_null_f(ARF, BRW_ARF_NULL, BRW_REGISTER_TYPE_F); -static const fs_reg reg_null_d(ARF, BRW_ARF_NULL, BRW_REGISTER_TYPE_D); - GLboolean brw_do_channel_expressions(struct exec_list *instructions); GLboolean brw_do_vector_splitting(struct exec_list *instructions); diff --git a/src/mesa/drivers/dri/i965/brw_fs_channel_expressions.cpp b/src/mesa/drivers/dri/i965/brw_fs_channel_expressions.cpp index 4aac1b5a05..3b7b03a05b 100644 --- a/src/mesa/drivers/dri/i965/brw_fs_channel_expressions.cpp +++ b/src/mesa/drivers/dri/i965/brw_fs_channel_expressions.cpp @@ -202,6 +202,7 @@ ir_channel_expressions_visitor::visit_leave(ir_assignment *ir) case ir_unop_ceil: case ir_unop_floor: case ir_unop_fract: + case ir_unop_round_even: case ir_unop_sin: case ir_unop_cos: case ir_unop_dFdx: @@ -287,34 +288,6 @@ ir_channel_expressions_visitor::visit_leave(ir_assignment *ir) break; } - case ir_binop_cross: { - for (i = 0; i < vector_elements; i++) { - int swiz0 = (i + 1) % 3; - int swiz1 = (i + 2) % 3; - ir_expression *temp1, *temp2; - - temp1 = new(mem_ctx) ir_expression(ir_binop_mul, - element_type, - get_element(op_var[0], swiz0), - get_element(op_var[1], swiz1)); - - temp2 = new(mem_ctx) ir_expression(ir_binop_mul, - element_type, - get_element(op_var[1], swiz0), - get_element(op_var[0], swiz1)); - - temp2 = new(mem_ctx) ir_expression(ir_unop_neg, - element_type, - temp2, - NULL); - - assign(ir, i, new(mem_ctx) ir_expression(ir_binop_add, - element_type, - temp1, temp2)); - } - break; - } - case ir_binop_logic_and: case ir_binop_logic_xor: case ir_binop_logic_or: diff --git a/src/mesa/drivers/dri/i965/brw_fs_reg_allocate.cpp b/src/mesa/drivers/dri/i965/brw_fs_reg_allocate.cpp index b5bfd00d5f..bbb210cd44 100644 --- a/src/mesa/drivers/dri/i965/brw_fs_reg_allocate.cpp +++ b/src/mesa/drivers/dri/i965/brw_fs_reg_allocate.cpp @@ -225,7 +225,7 @@ fs_visitor::assign_regs() * loop back into here to try again. */ int reg = choose_spill_reg(g); - if (reg == -1) { + if (reg == -1 || intel->gen >= 6) { this->fail = true; } else { spill_reg(reg); @@ -401,6 +401,7 @@ fs_visitor::spill_reg(int spill_reg) spill_src.reg_offset = 0; spill_src.abs = false; spill_src.negate = false; + spill_src.smear = -1; for (int chan = 0; chan < size; chan++) { fs_inst *spill_inst = new(mem_ctx) fs_inst(FS_OPCODE_SPILL, diff --git a/src/mesa/drivers/dri/i965/brw_gs.c b/src/mesa/drivers/dri/i965/brw_gs.c index cfcc8ea4d6..b0c76f4094 100644 --- a/src/mesa/drivers/dri/i965/brw_gs.c +++ b/src/mesa/drivers/dri/i965/brw_gs.c @@ -127,8 +127,8 @@ static void compile_gs_prog( struct brw_context *brw, */ program = brw_get_program(&c.func, &program_size); - if (INTEL_DEBUG & DEBUG_GS) { - int i; + if (unlikely(INTEL_DEBUG & DEBUG_GS)) { + int i; printf("gs:\n"); for (i = 0; i < program_size / sizeof(struct brw_instruction); i++) diff --git a/src/mesa/drivers/dri/i965/brw_gs_state.c b/src/mesa/drivers/dri/i965/brw_gs_state.c index 63562ebcfc..69a5f7a666 100644 --- a/src/mesa/drivers/dri/i965/brw_gs_state.c +++ b/src/mesa/drivers/dri/i965/brw_gs_state.c @@ -101,7 +101,7 @@ gs_unit_create_from_key(struct brw_context *brw, struct brw_gs_unit_key *key) if (intel->gen == 5) gs.thread4.rendering_enable = 1; - if (INTEL_DEBUG & DEBUG_STATS) + if (unlikely(INTEL_DEBUG & DEBUG_STATS)) gs.thread4.stats_enable = 1; bo = brw_upload_cache(&brw->cache, BRW_GS_UNIT, diff --git a/src/mesa/drivers/dri/i965/brw_misc_state.c b/src/mesa/drivers/dri/i965/brw_misc_state.c index 24041e57b0..1d350bc041 100644 --- a/src/mesa/drivers/dri/i965/brw_misc_state.c +++ b/src/mesa/drivers/dri/i965/brw_misc_state.c @@ -555,7 +555,7 @@ static void upload_invarient_state( struct brw_context *brw ) memset(&vfs, 0, sizeof(vfs)); vfs.opcode = brw->CMD_VF_STATISTICS; - if (INTEL_DEBUG & DEBUG_STATS) + if (unlikely(INTEL_DEBUG & DEBUG_STATS)) vfs.statistics_enable = 1; BRW_BATCH_STRUCT(brw, &vfs); diff --git a/src/mesa/drivers/dri/i965/brw_sf.c b/src/mesa/drivers/dri/i965/brw_sf.c index 7dbd70daae..6da155b1a9 100644 --- a/src/mesa/drivers/dri/i965/brw_sf.c +++ b/src/mesa/drivers/dri/i965/brw_sf.c @@ -108,7 +108,7 @@ static void compile_sf_prog( struct brw_context *brw, */ program = brw_get_program(&c.func, &program_size); - if (INTEL_DEBUG & DEBUG_SF) { + if (unlikely(INTEL_DEBUG & DEBUG_SF)) { printf("sf:\n"); for (i = 0; i < program_size / sizeof(struct brw_instruction); i++) brw_disasm(stdout, &((struct brw_instruction *)program)[i], diff --git a/src/mesa/drivers/dri/i965/brw_sf_state.c b/src/mesa/drivers/dri/i965/brw_sf_state.c index 6ad9e1b48a..bd3a21ed9e 100644 --- a/src/mesa/drivers/dri/i965/brw_sf_state.c +++ b/src/mesa/drivers/dri/i965/brw_sf_state.c @@ -210,10 +210,10 @@ sf_unit_create_from_key(struct brw_context *brw, struct brw_sf_unit_key *key, sf.thread4.max_threads = MIN2(chipset_max_threads, key->nr_urb_entries) - 1; - if (INTEL_DEBUG & DEBUG_SINGLE_THREAD) + if (unlikely(INTEL_DEBUG & DEBUG_SINGLE_THREAD)) sf.thread4.max_threads = 0; - if (INTEL_DEBUG & DEBUG_STATS) + if (unlikely(INTEL_DEBUG & DEBUG_STATS)) sf.thread4.stats_enable = 1; /* CACHE_NEW_SF_VP */ diff --git a/src/mesa/drivers/dri/i965/brw_state_cache.c b/src/mesa/drivers/dri/i965/brw_state_cache.c index b31d84953a..58ff528d44 100644 --- a/src/mesa/drivers/dri/i965/brw_state_cache.c +++ b/src/mesa/drivers/dri/i965/brw_state_cache.c @@ -61,6 +61,7 @@ #include "intel_batchbuffer.h" #include "brw_wm.h" +#define FILE_DEBUG_FLAG DEBUG_STATE static GLuint hash_key(struct brw_cache_item *item) @@ -265,10 +266,9 @@ brw_upload_cache_with_auxdata(struct brw_cache *cache, *(void **)aux_return = (void *)((char *)item->key + item->key_size); } - if (INTEL_DEBUG & DEBUG_STATE) - printf("upload %s: %d bytes to cache id %d\n", - cache->name[cache_id], - data_size, cache_id); + DBG("upload %s: %d bytes to cache id %d\n", + cache->name[cache_id], + data_size, cache_id); /* Copy data to the buffer */ drm_intel_bo_subdata(bo, 0, data_size, data); @@ -407,8 +407,7 @@ brw_clear_cache(struct brw_context *brw, struct brw_cache *cache) struct brw_cache_item *c, *next; GLuint i; - if (INTEL_DEBUG & DEBUG_STATE) - printf("%s\n", __FUNCTION__); + DBG("%s\n", __FUNCTION__); for (i = 0; i < cache->size; i++) { for (c = cache->items[i]; c; c = next) { @@ -434,8 +433,7 @@ brw_clear_cache(struct brw_context *brw, struct brw_cache *cache) void brw_state_cache_check_size(struct brw_context *brw) { - if (INTEL_DEBUG & DEBUG_STATE) - printf("%s (n_items=%d)\n", __FUNCTION__, brw->cache.n_items); + DBG("%s (n_items=%d)\n", __FUNCTION__, brw->cache.n_items); /* un-tuned guess. Each object is generally a page, so 1000 of them is 4 MB of * state cache. @@ -450,8 +448,7 @@ brw_destroy_cache(struct brw_context *brw, struct brw_cache *cache) { GLuint i; - if (INTEL_DEBUG & DEBUG_STATE) - printf("%s\n", __FUNCTION__); + DBG("%s\n", __FUNCTION__); brw_clear_cache(brw, cache); for (i = 0; i < BRW_MAX_CACHE; i++) { diff --git a/src/mesa/drivers/dri/i965/brw_state_dump.c b/src/mesa/drivers/dri/i965/brw_state_dump.c index b79b33c2e3..e262887471 100644 --- a/src/mesa/drivers/dri/i965/brw_state_dump.c +++ b/src/mesa/drivers/dri/i965/brw_state_dump.c @@ -107,14 +107,14 @@ static void dump_wm_surface_state(struct brw_context *brw) char name[20]; if (surf_bo == NULL) { - fprintf(stderr, " WM SS%d: NULL\n", i); + fprintf(stderr, "WM SURF%d: NULL\n", i); continue; } drm_intel_bo_map(surf_bo, GL_FALSE); surfoff = surf_bo->offset + brw->wm.surf_offset[i]; surf = (struct brw_surface_state *)(surf_bo->virtual + brw->wm.surf_offset[i]); - sprintf(name, "WM SS%d", i); + sprintf(name, "WM SURF%d", i); state_out(name, surf, surfoff, 0, "%s %s\n", get_965_surfacetype(surf->ss0.surface_type), get_965_surface_format(surf->ss0.surface_format)); @@ -132,6 +132,53 @@ static void dump_wm_surface_state(struct brw_context *brw) } } + +static void dump_wm_sampler_state(struct brw_context *brw) +{ + struct gl_context *ctx = &brw->intel.ctx; + int i; + + if (!brw->wm.sampler_bo) { + fprintf(stderr, "WM_SAMPLER: NULL\n"); + return; + } + + drm_intel_bo_map(brw->wm.sampler_bo, GL_FALSE); + for (i = 0; i < BRW_MAX_TEX_UNIT; i++) { + unsigned int offset; + struct brw_sampler_state *samp; + struct brw_sampler_default_color *sdc; + char name[20]; + + if (!ctx->Texture.Unit[i]._ReallyEnabled) { + fprintf(stderr, "WM SAMP%d: disabled\n", i); + continue; + } + + offset = brw->wm.sampler_bo->offset + + i * sizeof(struct brw_sampler_state); + samp = (struct brw_sampler_state *)(brw->wm.sampler_bo->virtual + + i * sizeof(struct brw_sampler_state)); + + sprintf(name, "WM SAMP%d", i); + state_out(name, samp, offset, 0, "filtering\n"); + state_out(name, samp, offset, 1, "wrapping, lod\n"); + state_out(name, samp, offset, 2, "default color pointer\n"); + state_out(name, samp, offset, 3, "chroma key, aniso\n"); + + sprintf(name, " WM SDC%d", i); + + drm_intel_bo_map(brw->wm.sdc_bo[i], GL_FALSE); + sdc = (struct brw_sampler_default_color *)(brw->wm.sdc_bo[i]->virtual); + state_out(name, sdc, brw->wm.sdc_bo[i]->offset, 0, "r\n"); + state_out(name, sdc, brw->wm.sdc_bo[i]->offset, 1, "g\n"); + state_out(name, sdc, brw->wm.sdc_bo[i]->offset, 2, "b\n"); + state_out(name, sdc, brw->wm.sdc_bo[i]->offset, 3, "a\n"); + drm_intel_bo_unmap(brw->wm.sdc_bo[i]); + } + drm_intel_bo_unmap(brw->wm.sampler_bo); +} + static void dump_sf_viewport_state(struct brw_context *brw) { const char *name = "SF VP"; @@ -324,6 +371,7 @@ void brw_debug_batch(struct intel_context *intel) state_struct_out("WM bind", brw->wm.bind_bo, 4 * brw->wm.nr_surfaces); dump_wm_surface_state(brw); + dump_wm_sampler_state(brw); if (intel->gen < 6) state_struct_out("VS", brw->vs.state_bo, sizeof(struct brw_vs_unit_state)); diff --git a/src/mesa/drivers/dri/i965/brw_state_upload.c b/src/mesa/drivers/dri/i965/brw_state_upload.c index 73940a5156..338f3876b3 100644 --- a/src/mesa/drivers/dri/i965/brw_state_upload.c +++ b/src/mesa/drivers/dri/i965/brw_state_upload.c @@ -128,6 +128,7 @@ const struct brw_tracked_state *gen6_atoms[] = &gen6_cc_state_pointers, &brw_vs_constants, /* Before vs_surfaces and constant_buffer */ + &brw_wm_constants, /* Before wm_surfaces and constant_buffer */ &gen6_wm_constants, /* Before wm_surfaces and constant_buffer */ &brw_vs_surfaces, /* must do before unit */ @@ -434,7 +435,7 @@ void brw_upload_state(struct brw_context *brw) brw_clear_validated_bos(brw); - if (INTEL_DEBUG) { + if (unlikely(INTEL_DEBUG)) { /* Debug version which enforces various sanity checks on the * state flags which are generated and checked to help ensure * state atoms are ordered correctly in the list. @@ -486,7 +487,7 @@ void brw_upload_state(struct brw_context *brw) } } - if (INTEL_DEBUG & DEBUG_STATE) { + if (unlikely(INTEL_DEBUG & DEBUG_STATE)) { brw_update_dirty_count(mesa_bits, state->mesa); brw_update_dirty_count(brw_bits, state->brw); brw_update_dirty_count(cache_bits, state->cache); diff --git a/src/mesa/drivers/dri/i965/brw_urb.c b/src/mesa/drivers/dri/i965/brw_urb.c index 0f597184b4..dfc1551aca 100644 --- a/src/mesa/drivers/dri/i965/brw_urb.c +++ b/src/mesa/drivers/dri/i965/brw_urb.c @@ -190,12 +190,12 @@ static void recalculate_urb_fence( struct brw_context *brw ) exit(1); } - if (INTEL_DEBUG & (DEBUG_URB|DEBUG_FALLBACKS)) + if (unlikely(INTEL_DEBUG & (DEBUG_URB|DEBUG_FALLBACKS))) printf("URB CONSTRAINED\n"); } done: - if (INTEL_DEBUG & DEBUG_URB) + if (unlikely(INTEL_DEBUG & DEBUG_URB)) printf("URB fence: %d ..VS.. %d ..GS.. %d ..CLP.. %d ..SF.. %d ..CS.. %d\n", brw->urb.vs_start, brw->urb.gs_start, diff --git a/src/mesa/drivers/dri/i965/brw_vs_emit.c b/src/mesa/drivers/dri/i965/brw_vs_emit.c index ce33479996..7e43324a1f 100644 --- a/src/mesa/drivers/dri/i965/brw_vs_emit.c +++ b/src/mesa/drivers/dri/i965/brw_vs_emit.c @@ -165,13 +165,20 @@ static void brw_vs_alloc_regs( struct brw_vs_compile *c ) /* User clip planes from curbe: */ if (c->key.nr_userclip) { - for (i = 0; i < c->key.nr_userclip; i++) { - c->userplane[i] = stride( brw_vec4_grf(reg+3+i/2, (i%2) * 4), 0, 4, 1); - } + if (intel->gen >= 6) { + for (i = 0; i < c->key.nr_userclip; i++) { + c->userplane[i] = stride(brw_vec4_grf(reg + i / 2, + (i % 2) * 4), 0, 4, 1); + } + reg += ALIGN(c->key.nr_userclip, 2) / 2; + } else { + for (i = 0; i < c->key.nr_userclip; i++) { + c->userplane[i] = stride(brw_vec4_grf(reg + (6 + i) / 2, + (i % 2) * 4), 0, 4, 1); + } + reg += (ALIGN(6 + c->key.nr_userclip, 4) / 4) * 2; + } - /* Deal with curbe alignment: - */ - reg += ((6 + c->key.nr_userclip + 3) / 4) * 2; } /* Vertex program parameters from curbe: @@ -253,9 +260,11 @@ static void brw_vs_alloc_regs( struct brw_vs_compile *c ) c->first_output = reg; c->first_overflow_output = 0; - if (intel->gen >= 6) - mrf = 3; /* no more pos store in attribute */ - else if (intel->gen == 5) + if (intel->gen >= 6) { + mrf = 3; + if (c->key.nr_userclip) + mrf += 2; + } else if (intel->gen == 5) mrf = 8; else mrf = 4; @@ -372,16 +381,20 @@ static void brw_vs_alloc_regs( struct brw_vs_compile *c ) /* See emit_vertex_write() for where the VUE's overhead on top of the * attributes comes from. */ - if (intel->gen >= 6) - c->prog_data.urb_entry_size = (attributes_in_vue + 2 + 7) / 8; - else if (intel->gen == 5) + if (intel->gen >= 6) { + int header_regs = 2; + if (c->key.nr_userclip) + header_regs += 2; + + c->prog_data.urb_entry_size = (attributes_in_vue + header_regs + 7) / 8; + } else if (intel->gen == 5) c->prog_data.urb_entry_size = (attributes_in_vue + 6 + 3) / 4; else c->prog_data.urb_entry_size = (attributes_in_vue + 2 + 3) / 4; c->prog_data.total_grf = reg; - if (INTEL_DEBUG & DEBUG_VS) { + if (unlikely(INTEL_DEBUG & DEBUG_VS)) { printf("%s NumAddrRegs %d\n", __FUNCTION__, c->vp->program.Base.NumAddressRegs); printf("%s NumTemps %d\n", __FUNCTION__, c->vp->program.Base.NumTemporaries); printf("%s reg = %d\n", __FUNCTION__, reg); @@ -576,12 +589,11 @@ static void emit_min( struct brw_compile *p, brw_set_predicate_control(p, BRW_PREDICATE_NONE); } - -static void emit_math1( struct brw_vs_compile *c, - GLuint function, - struct brw_reg dst, - struct brw_reg arg0, - GLuint precision) +static void emit_math1_gen4(struct brw_vs_compile *c, + GLuint function, + struct brw_reg dst, + struct brw_reg arg0, + GLuint precision) { /* There are various odd behaviours with SEND on the simulator. In * addition there are documented issues with the fact that the GEN4 @@ -591,14 +603,11 @@ static void emit_math1( struct brw_vs_compile *c, * whether that turns out to be a simulator bug or not: */ struct brw_compile *p = &c->func; - struct intel_context *intel = &p->brw->intel; struct brw_reg tmp = dst; GLboolean need_tmp = GL_FALSE; - if (dst.file != BRW_GENERAL_REGISTER_FILE) - need_tmp = GL_TRUE; - - if (intel->gen < 6 && dst.dw1.bits.writemask != 0xf) + if (dst.file != BRW_GENERAL_REGISTER_FILE || + dst.dw1.bits.writemask != 0xf) need_tmp = GL_TRUE; if (need_tmp) @@ -619,6 +628,57 @@ static void emit_math1( struct brw_vs_compile *c, } } +static void +emit_math1_gen6(struct brw_vs_compile *c, + GLuint function, + struct brw_reg dst, + struct brw_reg arg0, + GLuint precision) +{ + struct brw_compile *p = &c->func; + struct brw_reg tmp_src, tmp_dst; + + /* Something is strange on gen6 math in 16-wide mode, though the + * docs say it's supposed to work. Punt to using align1 mode, + * which doesn't do writemasking and swizzles. + */ + tmp_src = get_tmp(c); + tmp_dst = get_tmp(c); + + brw_MOV(p, tmp_src, arg0); + + brw_set_access_mode(p, BRW_ALIGN_1); + brw_math(p, + tmp_dst, + function, + BRW_MATH_SATURATE_NONE, + 2, + tmp_src, + BRW_MATH_DATA_SCALAR, + precision); + brw_set_access_mode(p, BRW_ALIGN_16); + + brw_MOV(p, dst, tmp_dst); + + release_tmp(c, tmp_src); + release_tmp(c, tmp_dst); +} + +static void +emit_math1(struct brw_vs_compile *c, + GLuint function, + struct brw_reg dst, + struct brw_reg arg0, + GLuint precision) +{ + struct brw_compile *p = &c->func; + struct intel_context *intel = &p->brw->intel; + + if (intel->gen >= 6) + emit_math1_gen6(c, function, dst, arg0, precision); + else + emit_math1_gen4(c, function, dst, arg0, precision); +} static void emit_math2( struct brw_vs_compile *c, GLuint function, @@ -1392,9 +1452,33 @@ static void emit_vertex_write( struct brw_vs_compile *c) /* Update the header for point size, user clipping flags, and -ve rhw * workaround. */ - if ((c->prog_data.outputs_written & BITFIELD64_BIT(VERT_RESULT_PSIZ)) || - c->key.nr_userclip || brw->has_negative_rhw_bug) - { + if (intel->gen >= 6) { + struct brw_reg m1 = brw_message_reg(1); + + /* On gen6, m1 has each value in a separate dword, so we never + * need to mess with a temporary for computing the m1 value. + */ + brw_MOV(p, retype(m1, BRW_REGISTER_TYPE_UD), brw_imm_ud(0)); + if (c->prog_data.outputs_written & BITFIELD64_BIT(VERT_RESULT_PSIZ)) { + brw_MOV(p, brw_writemask(m1, WRITEMASK_W), + brw_swizzle1(c->regs[PROGRAM_OUTPUT][VERT_RESULT_PSIZ], 0)); + } + + /* Set the user clip distances in dword 8-15. (m3-4)*/ + if (c->key.nr_userclip) { + for (i = 0; i < c->key.nr_userclip; i++) { + struct brw_reg m; + if (i < 4) + m = brw_message_reg(3); + else + m = brw_message_reg(4); + + brw_DP4(p, brw_writemask(m, (1 << (i & 7))),pos, c->userplane[i]); + } + } + } else if ((c->prog_data.outputs_written & + BITFIELD64_BIT(VERT_RESULT_PSIZ)) || + c->key.nr_userclip || brw->has_negative_rhw_bug) { struct brw_reg header1 = retype(get_tmp(c), BRW_REGISTER_TYPE_UD); GLuint i; @@ -1404,11 +1488,10 @@ static void emit_vertex_write( struct brw_vs_compile *c) if (c->prog_data.outputs_written & BITFIELD64_BIT(VERT_RESULT_PSIZ)) { struct brw_reg psiz = c->regs[PROGRAM_OUTPUT][VERT_RESULT_PSIZ]; - if (intel->gen < 6) { - brw_MUL(p, brw_writemask(header1, WRITEMASK_W), brw_swizzle1(psiz, 0), brw_imm_f(1<<11)); - brw_AND(p, brw_writemask(header1, WRITEMASK_W), header1, brw_imm_ud(0x7ff<<8)); - } else - brw_MOV(p, brw_writemask(header1, WRITEMASK_W), brw_swizzle1(psiz, 0)); + brw_MUL(p, brw_writemask(header1, WRITEMASK_W), + brw_swizzle1(psiz, 0), brw_imm_f(1<<11)); + brw_AND(p, brw_writemask(header1, WRITEMASK_W), + header1, brw_imm_ud(0x7ff<<8)); } for (i = 0; i < c->key.nr_userclip; i++) { @@ -1461,12 +1544,14 @@ static void emit_vertex_write( struct brw_vs_compile *c) * dword 0-3 (m1) of the header is indices, point width, clip flags. * dword 4-7 (m2) is the 4D space position * dword 8-15 (m3,m4) of the vertex header is the user clip distance if - * enabled. We don't use it, so skip it. - * m3 is the first vertex element data we fill, which is the vertex - * position. + * enabled. + * m3 or 5 is the first vertex element data we fill, which is + * the vertex position. */ brw_MOV(p, brw_message_reg(2), pos); len_vertex_header = 1; + if (c->key.nr_userclip > 0) + len_vertex_header += 2; } else if (intel->gen == 5) { /* There are 20 DWs (D0-D19) in VUE header on Ironlake: * dword 0-3 (m1) of the header is indices, point width, clip flags. @@ -1640,17 +1725,13 @@ void brw_vs_emit(struct brw_vs_compile *c ) GLuint index; GLuint file; - if (INTEL_DEBUG & DEBUG_VS) { + if (unlikely(INTEL_DEBUG & DEBUG_VS)) { printf("vs-mesa:\n"); _mesa_fprint_program_opt(stdout, &c->vp->program.Base, PROG_PRINT_DEBUG, GL_TRUE); printf("\n"); } - /* FIXME Need to fix conditional instruction to remove this */ - if (intel->gen >= 6) - p->single_program_flow = GL_TRUE; - brw_set_compression_control(p, BRW_COMPRESSION_NONE); brw_set_access_mode(p, BRW_ALIGN_16); if_depth_in_loop[loop_depth] = 0; @@ -2010,7 +2091,7 @@ void brw_vs_emit(struct brw_vs_compile *c ) brw_optimize(p); - if (INTEL_DEBUG & DEBUG_VS) { + if (unlikely(INTEL_DEBUG & DEBUG_VS)) { int i; printf("vs-native:\n"); diff --git a/src/mesa/drivers/dri/i965/brw_vs_state.c b/src/mesa/drivers/dri/i965/brw_vs_state.c index ebae94269f..be92313861 100644 --- a/src/mesa/drivers/dri/i965/brw_vs_state.c +++ b/src/mesa/drivers/dri/i965/brw_vs_state.c @@ -154,7 +154,7 @@ vs_unit_create_from_key(struct brw_context *brw, struct brw_vs_unit_key *key) */ vs.vs5.sampler_count = 0; - if (INTEL_DEBUG & DEBUG_STATS) + if (unlikely(INTEL_DEBUG & DEBUG_STATS)) vs.thread4.stats_enable = 1; /* Vertex program always enabled: diff --git a/src/mesa/drivers/dri/i965/brw_wm.c b/src/mesa/drivers/dri/i965/brw_wm.c index 7f3ba5f058..ccdc18e0b8 100644 --- a/src/mesa/drivers/dri/i965/brw_wm.c +++ b/src/mesa/drivers/dri/i965/brw_wm.c @@ -198,7 +198,7 @@ static void do_wm_prog( struct brw_context *brw, c->prog_data.total_scratch = 0; } - if (INTEL_DEBUG & DEBUG_WM) + if (unlikely(INTEL_DEBUG & DEBUG_WM)) fprintf(stderr, "\n"); /* get the program @@ -423,6 +423,7 @@ static void brw_wm_populate_key( struct brw_context *brw, */ if (fp->program.Base.InputsRead & FRAG_BIT_WPOS) { key->drawable_height = ctx->DrawBuffer->Height; + key->render_to_fbo = ctx->DrawBuffer->Name != 0; } key->nr_color_regions = brw->state.nr_color_regions; diff --git a/src/mesa/drivers/dri/i965/brw_wm.h b/src/mesa/drivers/dri/i965/brw_wm.h index 99bd15c187..2ca685784f 100644 --- a/src/mesa/drivers/dri/i965/brw_wm.h +++ b/src/mesa/drivers/dri/i965/brw_wm.h @@ -70,7 +70,8 @@ struct brw_wm_prog_key { GLuint linear_color:1; /**< linear interpolation vs perspective interp */ GLuint runtime_check_aads_emit:1; GLuint nr_color_regions:5; - + GLuint render_to_fbo:1; + GLbitfield proj_attrib_mask; /**< one bit per fragment program attribute */ GLuint shadowtex_mask:16; GLuint yuvtex_mask:16; diff --git a/src/mesa/drivers/dri/i965/brw_wm_emit.c b/src/mesa/drivers/dri/i965/brw_wm_emit.c index 88bc64e5dd..96fecc97ee 100644 --- a/src/mesa/drivers/dri/i965/brw_wm_emit.c +++ b/src/mesa/drivers/dri/i965/brw_wm_emit.c @@ -83,6 +83,7 @@ brw_wm_arg_can_be_immediate(enum prog_opcode opcode, int arg) [OPCODE_SLE] = 2, [OPCODE_SLT] = 2, [OPCODE_SNE] = 2, + [OPCODE_SWZ] = 1, [OPCODE_XPD] = 2, }; @@ -895,11 +896,12 @@ void emit_math1(struct brw_wm_compile *c, BRW_MATH_SATURATE_NONE); struct brw_reg src; - if (intel->gen >= 6 && arg0[0].hstride == BRW_HORIZONTAL_STRIDE_0) { - /* Gen6 math requires that source and dst horizontal stride be 1. - * + if (intel->gen >= 6 && (arg0[0].hstride == BRW_HORIZONTAL_STRIDE_0 || + arg0[0].file != BRW_GENERAL_REGISTER_FILE)) { + /* Gen6 math requires that source and dst horizontal stride be 1, + * and that the argument be in the GRF. */ - src = *dst; + src = dst[dst_chan]; brw_MOV(p, src, arg0[0]); } else { src = arg0[0]; @@ -1576,7 +1578,7 @@ static void emit_spill( struct brw_wm_compile *c, mov (1) r0.2<1>:d 0x00000080:d { Align1 NoMask } send (16) null.0<1>:uw m1 r0.0<8;8,1>:uw 0x053003ff:ud { Align1 } */ - brw_oword_block_write(p, brw_message_reg(1), 2, slot); + brw_oword_block_write_scratch(p, brw_message_reg(1), 2, slot); } @@ -1920,7 +1922,7 @@ void brw_wm_emit( struct brw_wm_compile *c ) brw_remove_grf_to_mrf_moves(p); } - if (INTEL_DEBUG & DEBUG_WM) { + if (unlikely(INTEL_DEBUG & DEBUG_WM)) { int i; printf("wm-native:\n"); diff --git a/src/mesa/drivers/dri/i965/brw_wm_fp.c b/src/mesa/drivers/dri/i965/brw_wm_fp.c index 15a238cda6..2cae698880 100644 --- a/src/mesa/drivers/dri/i965/brw_wm_fp.c +++ b/src/mesa/drivers/dri/i965/brw_wm_fp.c @@ -663,7 +663,7 @@ static void precalc_tex( struct brw_wm_compile *c, const struct prog_instruction *inst ) { struct prog_src_register coord; - struct prog_dst_register tmpcoord; + struct prog_dst_register tmpcoord = { 0 }; const GLuint unit = c->fp->program.Base.SamplerUnits[inst->TexSrcUnit]; assert(unit < BRW_MAX_TEX_UNIT); @@ -963,7 +963,7 @@ static void emit_render_target_writes( struct brw_wm_compile *c ) struct prog_src_register outcolor; GLuint i; - struct prog_instruction *inst, *last_inst; + struct prog_instruction *inst, *last_inst = NULL; /* The inst->Aux field is used for FB write target and the EOT marker */ @@ -1058,7 +1058,7 @@ void brw_wm_pass_fp( struct brw_wm_compile *c ) struct brw_fragment_program *fp = c->fp; GLuint insn; - if (INTEL_DEBUG & DEBUG_WM) { + if (unlikely(INTEL_DEBUG & DEBUG_WM)) { printf("pre-fp:\n"); _mesa_fprint_program_opt(stdout, &fp->program.Base, PROG_PRINT_DEBUG, GL_TRUE); @@ -1174,7 +1174,7 @@ void brw_wm_pass_fp( struct brw_wm_compile *c ) } } - if (INTEL_DEBUG & DEBUG_WM) { + if (unlikely(INTEL_DEBUG & DEBUG_WM)) { printf("pass_fp:\n"); print_insns( c->prog_instructions, c->nr_fp_insns ); printf("\n"); diff --git a/src/mesa/drivers/dri/i965/brw_wm_glsl.c b/src/mesa/drivers/dri/i965/brw_wm_glsl.c index 55aceea9b5..7fe8ab1f33 100644 --- a/src/mesa/drivers/dri/i965/brw_wm_glsl.c +++ b/src/mesa/drivers/dri/i965/brw_wm_glsl.c @@ -19,7 +19,7 @@ GLboolean brw_wm_is_glsl(const struct gl_fragment_program *fp) { int i; - if (INTEL_DEBUG & DEBUG_GLSL_FORCE) + if (unlikely(INTEL_DEBUG & DEBUG_GLSL_FORCE)) return GL_TRUE; for (i = 0; i < fp->Base.NumInstructions; i++) { @@ -307,21 +307,20 @@ static void prealloc_reg(struct brw_wm_compile *c) /* use a real constant buffer, or just use a section of the GRF? */ /* XXX this heuristic may need adjustment... */ - if ((nr_params + nr_temps) * 4 + reg_index > 80) - c->fp->use_const_buffer = GL_TRUE; - else - c->fp->use_const_buffer = GL_FALSE; - /*printf("WM use_const_buffer = %d\n", c->fp->use_const_buffer);*/ + if ((nr_params + nr_temps) * 4 + reg_index > 80) { + for (i = 0; i < nr_params; i++) { + float *pv = c->fp->program.Base.Parameters->ParameterValues[i]; + for (j = 0; j < 4; j++) { + c->prog_data.pull_param[c->prog_data.nr_pull_params] = &pv[j]; + c->prog_data.nr_pull_params++; + } + } - if (c->fp->use_const_buffer) { - /* We'll use a real constant buffer and fetch constants from - * it with a dataport read message. - */ + c->prog_data.nr_params = 0; + } + /*printf("WM use_const_buffer = %d\n", c->fp->use_const_buffer);*/ - /* number of float constants in CURBE */ - c->prog_data.nr_params = 0; - } - else { + if (!c->prog_data.nr_pull_params) { const struct gl_program_parameter_list *plist = c->fp->program.Base.Parameters; int index = 0; @@ -463,7 +462,7 @@ static void prealloc_reg(struct brw_wm_compile *c) * They'll be found in these registers. * XXX alloc these on demand! */ - if (c->fp->use_const_buffer) { + if (c->prog_data.nr_pull_params) { for (i = 0; i < 3; i++) { c->current_const[i].index = -1; c->current_const[i].reg = brw_vec8_grf(alloc_grf(c), 0); @@ -501,12 +500,11 @@ static void fetch_constants(struct brw_wm_compile *c, #endif /* need to fetch the constant now */ - brw_dp_READ_4(p, - c->current_const[i].reg, /* writeback dest */ - src->RelAddr, /* relative indexing? */ - 16 * src->Index, /* byte offset */ - SURF_INDEX_FRAG_CONST_BUFFER/* binding table index */ - ); + brw_oword_block_read(p, + c->current_const[i].reg, + brw_message_reg(1), + 16 * src->Index, + SURF_INDEX_FRAG_CONST_BUFFER); } } } @@ -606,7 +604,7 @@ static struct brw_reg get_src_reg(struct brw_wm_compile *c, } } - if (c->fp->use_const_buffer && + if (c->prog_data.nr_pull_params && (src->File == PROGRAM_STATE_VAR || src->File == PROGRAM_CONSTANT || src->File == PROGRAM_UNIFORM)) { @@ -729,7 +727,7 @@ static void brw_wm_emit_glsl(struct brw_context *brw, struct brw_wm_compile *c) #endif /* fetch any constants that this instruction needs */ - if (c->fp->use_const_buffer) + if (c->prog_data.nr_pull_params) fetch_constants(c, inst); if (inst->Opcode != OPCODE_ARL) { @@ -1004,7 +1002,7 @@ static void brw_wm_emit_glsl(struct brw_context *brw, struct brw_wm_compile *c) } post_wm_emit(c); - if (INTEL_DEBUG & DEBUG_WM) { + if (unlikely(INTEL_DEBUG & DEBUG_WM)) { printf("wm-native:\n"); for (i = 0; i < p->nr_insn; i++) brw_disasm(stdout, &p->store[i], intel->gen); @@ -1018,7 +1016,7 @@ static void brw_wm_emit_glsl(struct brw_context *brw, struct brw_wm_compile *c) */ void brw_wm_glsl_emit(struct brw_context *brw, struct brw_wm_compile *c) { - if (INTEL_DEBUG & DEBUG_WM) { + if (unlikely(INTEL_DEBUG & DEBUG_WM)) { printf("brw_wm_glsl_emit:\n"); } @@ -1028,7 +1026,7 @@ void brw_wm_glsl_emit(struct brw_context *brw, struct brw_wm_compile *c) /* actual code generation */ brw_wm_emit_glsl(brw, c); - if (INTEL_DEBUG & DEBUG_WM) { + if (unlikely(INTEL_DEBUG & DEBUG_WM)) { brw_wm_print_program(c, "brw_wm_glsl_emit done"); } diff --git a/src/mesa/drivers/dri/i965/brw_wm_pass0.c b/src/mesa/drivers/dri/i965/brw_wm_pass0.c index 8fc960b445..83152526b3 100644 --- a/src/mesa/drivers/dri/i965/brw_wm_pass0.c +++ b/src/mesa/drivers/dri/i965/brw_wm_pass0.c @@ -113,6 +113,7 @@ static const struct brw_wm_ref *get_param_ref( struct brw_wm_compile *c, struct brw_wm_ref *ref = get_ref(c); c->prog_data.param[i] = param_ptr; + c->prog_data.param_convert[i] = PARAM_NO_CONVERT; c->nr_creg = (i+16)/16; /* Push the offsets into hw_reg. These will be added to the @@ -439,7 +440,7 @@ void brw_wm_pass0( struct brw_wm_compile *c ) } } - if (INTEL_DEBUG & DEBUG_WM) { + if (unlikely(INTEL_DEBUG & DEBUG_WM)) { brw_wm_print_program(c, "pass0"); } } diff --git a/src/mesa/drivers/dri/i965/brw_wm_pass1.c b/src/mesa/drivers/dri/i965/brw_wm_pass1.c index 962515a99e..3a2874b6dd 100644 --- a/src/mesa/drivers/dri/i965/brw_wm_pass1.c +++ b/src/mesa/drivers/dri/i965/brw_wm_pass1.c @@ -291,7 +291,7 @@ void brw_wm_pass1( struct brw_wm_compile *c ) track_arg(c, inst, 2, read2); } - if (INTEL_DEBUG & DEBUG_WM) { + if (unlikely(INTEL_DEBUG & DEBUG_WM)) { brw_wm_print_program(c, "pass1"); } } diff --git a/src/mesa/drivers/dri/i965/brw_wm_pass2.c b/src/mesa/drivers/dri/i965/brw_wm_pass2.c index 54acb3038b..44e3953814 100644 --- a/src/mesa/drivers/dri/i965/brw_wm_pass2.c +++ b/src/mesa/drivers/dri/i965/brw_wm_pass2.c @@ -331,13 +331,13 @@ void brw_wm_pass2( struct brw_wm_compile *c ) } } - if (INTEL_DEBUG & DEBUG_WM) { + if (unlikely(INTEL_DEBUG & DEBUG_WM)) { brw_wm_print_program(c, "pass2"); } c->state = PASS2_DONE; - if (INTEL_DEBUG & DEBUG_WM) { + if (unlikely(INTEL_DEBUG & DEBUG_WM)) { brw_wm_print_program(c, "pass2/done"); } } diff --git a/src/mesa/drivers/dri/i965/brw_wm_state.c b/src/mesa/drivers/dri/i965/brw_wm_state.c index 433ccc66f0..76de7b7b6f 100644 --- a/src/mesa/drivers/dri/i965/brw_wm_state.c +++ b/src/mesa/drivers/dri/i965/brw_wm_state.c @@ -137,9 +137,9 @@ wm_unit_populate_key(struct brw_context *brw, struct brw_wm_unit_key *key) /* If using the fragment shader backend, the program is always * 8-wide. */ - if (ctx->Shader.CurrentProgram) { + if (ctx->Shader.CurrentFragmentProgram) { struct brw_shader *shader = (struct brw_shader *) - ctx->Shader.CurrentProgram->_LinkedShaders[MESA_SHADER_FRAGMENT]; + ctx->Shader.CurrentFragmentProgram->_LinkedShaders[MESA_SHADER_FRAGMENT]; if (shader != NULL && shader->ir != NULL) { key->is_glsl = GL_TRUE; @@ -249,7 +249,7 @@ wm_unit_create_from_key(struct brw_context *brw, struct brw_wm_unit_key *key, wm.wm5.line_stipple = key->line_stipple; - if (INTEL_DEBUG & DEBUG_STATS || key->stats_wm) + if (unlikely(INTEL_DEBUG & DEBUG_STATS) || key->stats_wm) wm.wm4.stats_enable = 1; bo = brw_upload_cache(&brw->cache, BRW_WM_UNIT, diff --git a/src/mesa/drivers/dri/i965/brw_wm_surface_state.c b/src/mesa/drivers/dri/i965/brw_wm_surface_state.c index 5588702afc..76fc94df1f 100644 --- a/src/mesa/drivers/dri/i965/brw_wm_surface_state.c +++ b/src/mesa/drivers/dri/i965/brw_wm_surface_state.c @@ -319,13 +319,14 @@ prepare_wm_constants(struct brw_context *brw) struct intel_context *intel = &brw->intel; struct brw_fragment_program *fp = (struct brw_fragment_program *) brw->fragment_program; - const struct gl_program_parameter_list *params = fp->program.Base.Parameters; - const int size = params->NumParameters * 4 * sizeof(GLfloat); + const int size = brw->wm.prog_data->nr_pull_params * sizeof(float); + float *constants; + unsigned int i; _mesa_load_state_parameters(ctx, fp->program.Base.Parameters); /* BRW_NEW_FRAGMENT_PROGRAM */ - if (!fp->use_const_buffer) { + if (brw->wm.prog_data->nr_pull_params == 0) { if (brw->wm.const_bo) { drm_intel_bo_unreference(brw->wm.const_bo); brw->wm.const_bo = NULL; @@ -335,11 +336,19 @@ prepare_wm_constants(struct brw_context *brw) } drm_intel_bo_unreference(brw->wm.const_bo); - brw->wm.const_bo = drm_intel_bo_alloc(intel->bufmgr, "vp_const_buffer", + brw->wm.const_bo = drm_intel_bo_alloc(intel->bufmgr, "WM const bo", size, 64); /* _NEW_PROGRAM_CONSTANTS */ - drm_intel_bo_subdata(brw->wm.const_bo, 0, size, params->ParameterValues); + drm_intel_gem_bo_map_gtt(brw->wm.const_bo); + constants = brw->wm.const_bo->virtual; + for (i = 0; i < brw->wm.prog_data->nr_pull_params; i++) { + constants[i] = convert_param(brw->wm.prog_data->pull_param_convert[i], + *brw->wm.prog_data->pull_param[i]); + } + drm_intel_gem_bo_unmap_gtt(brw->wm.const_bo); + + brw->state.dirty.brw |= BRW_NEW_WM_CONSTBUF; } const struct brw_tracked_state brw_wm_constants = { diff --git a/src/mesa/drivers/dri/i965/gen6_cc.c b/src/mesa/drivers/dri/i965/gen6_cc.c index 0d6e923f73..800a255521 100644 --- a/src/mesa/drivers/dri/i965/gen6_cc.c +++ b/src/mesa/drivers/dri/i965/gen6_cc.c @@ -254,7 +254,7 @@ prepare_color_calc_state(struct brw_context *brw) const struct brw_tracked_state gen6_color_calc_state = { .dirty = { - .mesa = _NEW_COLOR, + .mesa = _NEW_COLOR | _NEW_STENCIL, .brw = 0, .cache = 0, }, diff --git a/src/mesa/drivers/dri/i965/gen6_clip_state.c b/src/mesa/drivers/dri/i965/gen6_clip_state.c index cd2ac9d92f..c65b41e2b6 100644 --- a/src/mesa/drivers/dri/i965/gen6_clip_state.c +++ b/src/mesa/drivers/dri/i965/gen6_clip_state.c @@ -28,6 +28,7 @@ #include "brw_context.h" #include "brw_state.h" #include "brw_defines.h" +#include "brw_util.h" #include "intel_batchbuffer.h" static void @@ -36,7 +37,7 @@ upload_clip_state(struct brw_context *brw) struct intel_context *intel = &brw->intel; struct gl_context *ctx = &intel->ctx; uint32_t depth_clamp = 0; - uint32_t provoking; + uint32_t provoking, userclip; if (!ctx->Transform.DepthClamp) depth_clamp = GEN6_CLIP_Z_TEST; @@ -50,6 +51,9 @@ upload_clip_state(struct brw_context *brw) (1 << GEN6_CLIP_LINE_PROVOKE_SHIFT); } + /* _NEW_TRANSFORM */ + userclip = (1 << brw_count_bits(ctx->Transform.ClipPlanesEnabled)) - 1; + BEGIN_BATCH(4); OUT_BATCH(CMD_3D_CLIP_STATE << 16 | (4 - 2)); OUT_BATCH(GEN6_CLIP_STATISTICS_ENABLE); @@ -57,6 +61,7 @@ upload_clip_state(struct brw_context *brw) GEN6_CLIP_API_OGL | GEN6_CLIP_MODE_NORMAL | GEN6_CLIP_XY_TEST | + userclip << GEN6_USER_CLIP_CLIP_DISTANCES_SHIFT | depth_clamp | provoking); OUT_BATCH(GEN6_CLIP_FORCE_ZERO_RTAINDEX); diff --git a/src/mesa/drivers/dri/i965/gen6_sf_state.c b/src/mesa/drivers/dri/i965/gen6_sf_state.c index 55a70bea62..471067e8f0 100644 --- a/src/mesa/drivers/dri/i965/gen6_sf_state.c +++ b/src/mesa/drivers/dri/i965/gen6_sf_state.c @@ -73,12 +73,19 @@ upload_sf_state(struct brw_context *brw) /* _NEW_BUFFER */ GLboolean render_to_fbo = brw->intel.ctx.DrawBuffer->Name != 0; int attr = 0; + int urb_start; + + /* _NEW_TRANSFORM */ + if (ctx->Transform.ClipPlanesEnabled) + urb_start = 2; + else + urb_start = 1; dw1 = GEN6_SF_SWIZZLE_ENABLE | num_outputs << GEN6_SF_NUM_OUTPUTS_SHIFT | (num_inputs + 1) / 2 << GEN6_SF_URB_ENTRY_READ_LENGTH_SHIFT | - 1 << GEN6_SF_URB_ENTRY_READ_OFFSET_SHIFT; + urb_start << GEN6_SF_URB_ENTRY_READ_OFFSET_SHIFT; dw2 = GEN6_SF_VIEWPORT_TRANSFORM_ENABLE | GEN6_SF_STATISTICS_ENABLE; dw3 = 0; @@ -195,7 +202,9 @@ const struct brw_tracked_state gen6_sf_state = { _NEW_POLYGON | _NEW_LINE | _NEW_SCISSOR | - _NEW_BUFFERS), + _NEW_BUFFERS | + _NEW_POINT | + _NEW_TRANSFORM), .brw = BRW_NEW_CONTEXT, .cache = CACHE_NEW_VS_PROG }, diff --git a/src/mesa/drivers/dri/i965/gen6_urb.c b/src/mesa/drivers/dri/i965/gen6_urb.c index 0a264fcd90..a34123478f 100644 --- a/src/mesa/drivers/dri/i965/gen6_urb.c +++ b/src/mesa/drivers/dri/i965/gen6_urb.c @@ -40,7 +40,7 @@ prepare_urb( struct brw_context *brw ) else brw->urb.nr_gs_entries = 0; /* CACHE_NEW_VS_PROG */ - brw->urb.vs_size = MIN2(brw->vs.prog_data->urb_entry_size, 1); + brw->urb.vs_size = MAX2(brw->vs.prog_data->urb_entry_size, 1); /* Check that the number of URB rows (8 floats each) allocated is less * than the URB space. diff --git a/src/mesa/drivers/dri/i965/gen6_vs_state.c b/src/mesa/drivers/dri/i965/gen6_vs_state.c index 304eaddf40..e94d0c0ddb 100644 --- a/src/mesa/drivers/dri/i965/gen6_vs_state.c +++ b/src/mesa/drivers/dri/i965/gen6_vs_state.c @@ -40,11 +40,11 @@ upload_vs_state(struct brw_context *brw) struct gl_context *ctx = &intel->ctx; const struct brw_vertex_program *vp = brw_vertex_program_const(brw->vertex_program); - unsigned int nr_params = vp->program.Base.Parameters->NumParameters; + unsigned int nr_params = brw->vs.prog_data->nr_params / 4; drm_intel_bo *constant_bo; int i; - if (vp->use_const_buffer || nr_params == 0) { + if (brw->vs.prog_data->nr_params == 0 && !ctx->Transform.ClipPlanesEnabled) { /* Disable the push constant buffers. */ BEGIN_BATCH(5); OUT_BATCH(CMD_3D_CONSTANT_VS_STATE << 16 | (5 - 2)); @@ -54,6 +54,9 @@ upload_vs_state(struct brw_context *brw) OUT_BATCH(0); ADVANCE_BATCH(); } else { + int params_uploaded = 0; + float *param; + if (brw->vertex_program->IsNVProgram) _mesa_load_tracked_matrices(ctx); @@ -63,14 +66,55 @@ upload_vs_state(struct brw_context *brw) _mesa_load_state_parameters(ctx, vp->program.Base.Parameters); constant_bo = drm_intel_bo_alloc(intel->bufmgr, "VS constant_bo", - nr_params * 4 * sizeof(float), + (MAX_CLIP_PLANES + nr_params) * + 4 * sizeof(float), 4096); drm_intel_gem_bo_map_gtt(constant_bo); - for (i = 0; i < nr_params; i++) { - memcpy((char *)constant_bo->virtual + i * 4 * sizeof(float), - vp->program.Base.Parameters->ParameterValues[i], - 4 * sizeof(float)); + param = constant_bo->virtual; + + /* This should be loaded like any other param, but it's ad-hoc + * until we redo the VS backend. + */ + for (i = 0; i < MAX_CLIP_PLANES; i++) { + if (ctx->Transform.ClipPlanesEnabled & (1 << i)) { + memcpy(param, ctx->Transform._ClipUserPlane[i], 4 * sizeof(float)); + param += 4; + params_uploaded++; + } } + /* Align to a reg for convenience for brw_vs_emit.c */ + if (params_uploaded & 1) { + param += 4; + params_uploaded++; + } + + if (vp->use_const_buffer) { + for (i = 0; i < vp->program.Base.Parameters->NumParameters; i++) { + if (brw->vs.constant_map[i] != -1) { + memcpy(param + brw->vs.constant_map[i] * 4, + vp->program.Base.Parameters->ParameterValues[i], + 4 * sizeof(float)); + params_uploaded++; + } + } + } else { + for (i = 0; i < nr_params; i++) { + memcpy(param, vp->program.Base.Parameters->ParameterValues[i], + 4 * sizeof(float)); + param += 4; + params_uploaded++; + } + } + + if (0) { + printf("VS constant buffer:\n"); + for (i = 0; i < params_uploaded; i++) { + float *buf = (float *)constant_bo->virtual + i * 4; + printf("%d: %f %f %f %f\n", + i, buf[0], buf[1], buf[2], buf[3]); + } + } + drm_intel_gem_bo_unmap_gtt(constant_bo); BEGIN_BATCH(5); @@ -79,7 +123,7 @@ upload_vs_state(struct brw_context *brw) (5 - 2)); OUT_RELOC(constant_bo, I915_GEM_DOMAIN_RENDER, 0, /* XXX: bad domain */ - ALIGN(nr_params, 2) / 2 - 1); + ALIGN(params_uploaded, 2) / 2 - 1); OUT_BATCH(0); OUT_BATCH(0); OUT_BATCH(0); @@ -91,7 +135,7 @@ upload_vs_state(struct brw_context *brw) BEGIN_BATCH(6); OUT_BATCH(CMD_3D_VS_STATE << 16 | (6 - 2)); OUT_RELOC(brw->vs.prog_bo, I915_GEM_DOMAIN_INSTRUCTION, 0, 0); - OUT_BATCH(GEN6_VS_SPF_MODE | (0 << GEN6_VS_SAMPLER_COUNT_SHIFT) | + OUT_BATCH((0 << GEN6_VS_SAMPLER_COUNT_SHIFT) | (brw->vs.nr_surfaces << GEN6_VS_BINDING_TABLE_ENTRY_COUNT_SHIFT)); OUT_BATCH(0); /* scratch space base offset */ OUT_BATCH((1 << GEN6_VS_DISPATCH_START_GRF_SHIFT) | diff --git a/src/mesa/drivers/dri/i965/gen6_wm_state.c b/src/mesa/drivers/dri/i965/gen6_wm_state.c index 21059be965..ea5418bacf 100644 --- a/src/mesa/drivers/dri/i965/gen6_wm_state.c +++ b/src/mesa/drivers/dri/i965/gen6_wm_state.c @@ -63,7 +63,8 @@ prepare_wm_constants(struct brw_context *brw) drm_intel_gem_bo_map_gtt(brw->wm.push_const_bo); constants = brw->wm.push_const_bo->virtual; for (i = 0; i < brw->wm.prog_data->nr_params; i++) { - constants[i] = *brw->wm.prog_data->param[i]; + constants[i] = convert_param(brw->wm.prog_data->param_convert[i], + *brw->wm.prog_data->param[i]); } drm_intel_gem_bo_unmap_gtt(brw->wm.push_const_bo); } @@ -72,7 +73,7 @@ prepare_wm_constants(struct brw_context *brw) const struct brw_tracked_state gen6_wm_constants = { .dirty = { .mesa = _NEW_PROGRAM_CONSTANTS, - .brw = 0, + .brw = BRW_NEW_FRAGMENT_PROGRAM, .cache = 0, }, .prepare = prepare_wm_constants, @@ -87,7 +88,7 @@ upload_wm_state(struct brw_context *brw) brw_fragment_program_const(brw->fragment_program); uint32_t dw2, dw4, dw5, dw6; - if (fp->use_const_buffer || brw->wm.prog_data->nr_params == 0) { + if (brw->wm.prog_data->nr_params == 0) { /* Disable the push constant buffers. */ BEGIN_BATCH(5); OUT_BATCH(CMD_3D_CONSTANT_PS_STATE << 16 | (5 - 2)); @@ -115,7 +116,7 @@ upload_wm_state(struct brw_context *brw) dw5 |= GEN6_WM_LINE_AA_WIDTH_1_0; dw5 |= GEN6_WM_LINE_END_CAP_AA_WIDTH_0_5; - /* BRW_NEW_NR_SURFACES */ + /* BRW_NEW_NR_WM_SURFACES */ dw2 |= brw->wm.nr_surfaces << GEN6_WM_BINDING_TABLE_ENTRY_COUNT_SHIFT; /* CACHE_NEW_SAMPLER */ diff --git a/src/mesa/drivers/dri/i965/intel_structs.h b/src/mesa/drivers/dri/i965/intel_structs.h deleted file mode 100644 index 522e3bd92c..0000000000 --- a/src/mesa/drivers/dri/i965/intel_structs.h +++ /dev/null @@ -1,132 +0,0 @@ -#ifndef INTEL_STRUCTS_H -#define INTEL_STRUCTS_H - -struct br0 { - GLuint length:8; - GLuint pad0:3; - GLuint dst_tiled:1; - GLuint pad1:8; - GLuint write_rgb:1; - GLuint write_alpha:1; - GLuint opcode:7; - GLuint client:3; -}; - - -struct br13 { - GLint dest_pitch:16; - GLuint rop:8; - GLuint color_depth:2; - GLuint pad1:3; - GLuint mono_source_transparency:1; - GLuint clipping_enable:1; - GLuint pad0:1; -}; - - - -/* This is an attempt to move some of the 2D interaction in this - * driver to using structs for packets rather than a bunch of #defines - * and dwords. - */ -struct xy_color_blit { - struct br0 br0; - struct br13 br13; - - struct { - GLuint dest_x1:16; - GLuint dest_y1:16; - } dw2; - - struct { - GLuint dest_x2:16; - GLuint dest_y2:16; - } dw3; - - GLuint dest_base_addr; - GLuint color; -}; - -struct xy_src_copy_blit { - struct br0 br0; - struct br13 br13; - - struct { - GLuint dest_x1:16; - GLuint dest_y1:16; - } dw2; - - struct { - GLuint dest_x2:16; - GLuint dest_y2:16; - } dw3; - - GLuint dest_base_addr; - - struct { - GLuint src_x1:16; - GLuint src_y1:16; - } dw5; - - struct { - GLint src_pitch:16; - GLuint pad:16; - } dw6; - - GLuint src_base_addr; -}; - -struct xy_setup_blit { - struct br0 br0; - struct br13 br13; - - struct { - GLuint clip_x1:16; - GLuint clip_y1:16; - } dw2; - - struct { - GLuint clip_x2:16; - GLuint clip_y2:16; - } dw3; - - GLuint dest_base_addr; - GLuint background_color; - GLuint foreground_color; - GLuint pattern_base_addr; -}; - - -struct xy_text_immediate_blit { - struct { - GLuint length:8; - GLuint pad2:3; - GLuint dst_tiled:1; - GLuint pad1:4; - GLuint byte_packed:1; - GLuint pad0:5; - GLuint opcode:7; - GLuint client:3; - } dw0; - - struct { - GLuint dest_x1:16; - GLuint dest_y1:16; - } dw1; - - struct { - GLuint dest_x2:16; - GLuint dest_y2:16; - } dw2; - - /* Src bitmap data follows as inline dwords. - */ -}; - - -#define CLIENT_2D 0x2 -#define OPCODE_XY_SETUP_BLT 0x1 -#define OPCODE_XY_COLOR_BLT 0x50 -#define OPCODE_XY_TEXT_IMMEDIATE_BLT 0x31 - -#endif diff --git a/src/mesa/drivers/dri/intel/intel_batchbuffer.c b/src/mesa/drivers/dri/intel/intel_batchbuffer.c index 9b39823917..4b498f8c5b 100644 --- a/src/mesa/drivers/dri/intel/intel_batchbuffer.c +++ b/src/mesa/drivers/dri/intel/intel_batchbuffer.c @@ -44,7 +44,9 @@ intel_batchbuffer_reset(struct intel_batchbuffer *batch) batch->buf = drm_intel_bo_alloc(intel->bufmgr, "batchbuffer", intel->maxBatchSize, 4096); - batch->map = batch->buffer; + drm_intel_gem_bo_map_gtt(batch->buf); + batch->map = batch->buf->virtual; + batch->size = intel->maxBatchSize; batch->ptr = batch->map; batch->reserved_space = BATCH_RESERVED; @@ -58,7 +60,6 @@ intel_batchbuffer_alloc(struct intel_context *intel) struct intel_batchbuffer *batch = calloc(sizeof(*batch), 1); batch->intel = intel; - batch->buffer = malloc(intel->maxBatchSize); intel_batchbuffer_reset(batch); return batch; @@ -67,8 +68,11 @@ intel_batchbuffer_alloc(struct intel_context *intel) void intel_batchbuffer_free(struct intel_batchbuffer *batch) { - free (batch->buffer); - drm_intel_bo_unreference(batch->buf); + if (batch->map) { + drm_intel_gem_bo_unmap_gtt(batch->buf); + batch->map = NULL; + } + dri_bo_unreference(batch->buf); batch->buf = NULL; free(batch); } @@ -84,13 +88,7 @@ do_flush_locked(struct intel_batchbuffer *batch, GLuint used) int ret = 0; int x_off = 0, y_off = 0; - drm_intel_bo_subdata(batch->buf, 0, used, batch->buffer); - if (batch->state_batch_offset != batch->size) { - drm_intel_bo_subdata(batch->buf, - batch->state_batch_offset, - batch->size - batch->state_batch_offset, - batch->buffer + batch->state_batch_offset); - } + drm_intel_gem_bo_unmap_gtt(batch->buf); batch->ptr = NULL; @@ -99,7 +97,7 @@ do_flush_locked(struct intel_batchbuffer *batch, GLuint used) (x_off & 0xffff) | (y_off << 16)); } - if (INTEL_DEBUG & DEBUG_BATCH) { + if (unlikely(INTEL_DEBUG & DEBUG_BATCH)) { drm_intel_bo_map(batch->buf, GL_FALSE); intel_decode(batch->buf->virtual, used / 4, batch->buf->offset, intel->intelScreen->deviceID, GL_TRUE); @@ -130,7 +128,7 @@ _intel_batchbuffer_flush(struct intel_batchbuffer *batch, const char *file, if (used == 0) return; - if (INTEL_DEBUG & DEBUG_BATCH) + if (unlikely(INTEL_DEBUG & DEBUG_BATCH)) fprintf(stderr, "%s:%d: Batchbuffer flush with %db used\n", file, line, used); @@ -174,7 +172,7 @@ _intel_batchbuffer_flush(struct intel_batchbuffer *batch, const char *file, do_flush_locked(batch, used); - if (INTEL_DEBUG & DEBUG_SYNC) { + if (unlikely(INTEL_DEBUG & DEBUG_SYNC)) { fprintf(stderr, "waiting for idle\n"); drm_intel_bo_map(batch->buf, GL_TRUE); drm_intel_bo_unmap(batch->buf); diff --git a/src/mesa/drivers/dri/intel/intel_batchbuffer.h b/src/mesa/drivers/dri/intel/intel_batchbuffer.h index ae53f45511..428c027c2f 100644 --- a/src/mesa/drivers/dri/intel/intel_batchbuffer.h +++ b/src/mesa/drivers/dri/intel/intel_batchbuffer.h @@ -17,8 +17,6 @@ struct intel_batchbuffer drm_intel_bo *buf; - GLubyte *buffer; - GLubyte *map; GLubyte *ptr; diff --git a/src/mesa/drivers/dri/intel/intel_blit.c b/src/mesa/drivers/dri/intel/intel_blit.c index a74e21720f..c2917e9b07 100644 --- a/src/mesa/drivers/dri/intel/intel_blit.c +++ b/src/mesa/drivers/dri/intel/intel_blit.c @@ -483,8 +483,11 @@ intel_emit_linear_blit(struct intel_context *intel, /* Blits are in a different ringbuffer so we don't use them. */ assert(intel->gen < 6); - /* The pitch is a signed value. */ - pitch = MIN2(size, (1 << 15) - 1); + /* The pitch given to the GPU must be DWORD aligned, and + * we want width to match pitch. Max width is (1 << 15 - 1), + * rounding that down to the nearest DWORD is 1 << 15 - 4 + */ + pitch = MIN2(size, (1 << 15) - 4); height = size / pitch; ok = intelEmitCopyBlit(intel, 1, pitch, src_bo, src_offset, I915_TILING_NONE, @@ -499,6 +502,7 @@ intel_emit_linear_blit(struct intel_context *intel, dst_offset += pitch * height; size -= pitch * height; assert (size < (1 << 15)); + assert ((size & 3) == 0); /* Pitch must be DWORD aligned */ if (size != 0) { ok = intelEmitCopyBlit(intel, 1, size, src_bo, src_offset, I915_TILING_NONE, diff --git a/src/mesa/drivers/dri/intel/intel_chipset.h b/src/mesa/drivers/dri/intel/intel_chipset.h index 1e7ceed32a..4fecdbed20 100644 --- a/src/mesa/drivers/dri/intel/intel_chipset.h +++ b/src/mesa/drivers/dri/intel/intel_chipset.h @@ -67,6 +67,7 @@ #define PCI_CHIP_G45_G 0x2E22 #define PCI_CHIP_G41_G 0x2E32 #define PCI_CHIP_B43_G 0x2E42 +#define PCI_CHIP_B43_G1 0x2E92 #define PCI_CHIP_ILD_G 0x0042 #define PCI_CHIP_ILM_G 0x0046 @@ -93,7 +94,8 @@ devid == PCI_CHIP_Q45_G || \ devid == PCI_CHIP_G45_G || \ devid == PCI_CHIP_G41_G || \ - devid == PCI_CHIP_B43_G) + devid == PCI_CHIP_B43_G || \ + devid == PCI_CHIP_B43_G1) #define IS_GM45(devid) (devid == PCI_CHIP_GM45_GM) #define IS_G4X(devid) (IS_G45(devid) || IS_GM45(devid)) diff --git a/src/mesa/drivers/dri/intel/intel_clear.c b/src/mesa/drivers/dri/intel/intel_clear.c index d7814635b7..fa451f0045 100644 --- a/src/mesa/drivers/dri/intel/intel_clear.c +++ b/src/mesa/drivers/dri/intel/intel_clear.c @@ -58,6 +58,21 @@ static const char *buffer_names[] = { [BUFFER_COLOR7] = "color7", }; +static void +debug_mask(const char *name, GLbitfield mask) +{ + GLuint i; + + if (unlikely(INTEL_DEBUG & DEBUG_BLIT)) { + DBG("%s clear:", name); + for (i = 0; i < BUFFER_COUNT; i++) { + if (mask & (1 << i)) + DBG(" %s", buffer_names[i]); + } + DBG("\n"); + } +} + /** * Called by ctx->Driver.Clear. */ @@ -70,7 +85,6 @@ intelClear(struct gl_context *ctx, GLbitfield mask) GLbitfield blit_mask = 0; GLbitfield swrast_mask = 0; struct gl_framebuffer *fb = ctx->DrawBuffer; - GLuint i; if (mask & (BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_FRONT_RIGHT)) { intel->front_buffer_dirty = GL_TRUE; @@ -162,39 +176,17 @@ intelClear(struct gl_context *ctx, GLbitfield mask) } if (blit_mask) { - if (INTEL_DEBUG & DEBUG_BLIT) { - DBG("blit clear:"); - for (i = 0; i < BUFFER_COUNT; i++) { - if (blit_mask & (1 << i)) - DBG(" %s", buffer_names[i]); - } - DBG("\n"); - } + debug_mask("blit", blit_mask); intelClearWithBlit(ctx, blit_mask); } if (tri_mask) { - if (INTEL_DEBUG & DEBUG_BLIT) { - DBG("tri clear:"); - for (i = 0; i < BUFFER_COUNT; i++) { - if (tri_mask & (1 << i)) - DBG(" %s", buffer_names[i]); - } - DBG("\n"); - } - + debug_mask("tri", tri_mask); _mesa_meta_Clear(&intel->ctx, tri_mask); } if (swrast_mask) { - if (INTEL_DEBUG & DEBUG_BLIT) { - DBG("swrast clear:"); - for (i = 0; i < BUFFER_COUNT; i++) { - if (swrast_mask & (1 << i)) - DBG(" %s", buffer_names[i]); - } - DBG("\n"); - } + debug_mask("swrast", swrast_mask); _swrast_Clear(ctx, swrast_mask); } } diff --git a/src/mesa/drivers/dri/intel/intel_context.c b/src/mesa/drivers/dri/intel/intel_context.c index 7ace50bde9..152cdcaf37 100644 --- a/src/mesa/drivers/dri/intel/intel_context.c +++ b/src/mesa/drivers/dri/intel/intel_context.c @@ -155,6 +155,7 @@ intelGetString(struct gl_context * ctx, GLenum name) chipset = "Intel(R) G41"; break; case PCI_CHIP_B43_G: + case PCI_CHIP_B43_G1: chipset = "Intel(R) B43"; break; case PCI_CHIP_ILD_G: @@ -249,7 +250,7 @@ intel_update_renderbuffers(__DRIcontext *context, __DRIdrawable *drawable) * thus ignore the invalidate. */ drawable->lastStamp = drawable->dri2.stamp; - if (INTEL_DEBUG & DEBUG_DRI) + if (unlikely(INTEL_DEBUG & DEBUG_DRI)) fprintf(stderr, "enter %s, drawable %p\n", __func__, drawable); screen = intel->intelScreen->driScrnPriv; @@ -378,14 +379,14 @@ intel_update_renderbuffers(__DRIcontext *context, __DRIdrawable *drawable) if (rb->region && rb->region->name == buffers[i].name) continue; - if (INTEL_DEBUG & DEBUG_DRI) + if (unlikely(INTEL_DEBUG & DEBUG_DRI)) fprintf(stderr, "attaching buffer %d, at %d, cpp %d, pitch %d\n", buffers[i].name, buffers[i].attachment, buffers[i].cpp, buffers[i].pitch); if (buffers[i].attachment == __DRI_BUFFER_STENCIL && depth_region) { - if (INTEL_DEBUG & DEBUG_DRI) + if (unlikely(INTEL_DEBUG & DEBUG_DRI)) fprintf(stderr, "(reusing depth buffer as stencil)\n"); intel_region_reference(®ion, depth_region); } diff --git a/src/mesa/drivers/dri/intel/intel_context.h b/src/mesa/drivers/dri/intel/intel_context.h index 46d10d74ba..9d5139c000 100644 --- a/src/mesa/drivers/dri/intel/intel_context.h +++ b/src/mesa/drivers/dri/intel/intel_context.h @@ -98,6 +98,16 @@ extern void intelFallback(struct intel_context *intel, GLbitfield bit, #define INTEL_MAX_FIXUP 64 +#ifndef likely +#ifdef __GNUC__ +#define likely(expr) (__builtin_expect(expr, 1)) +#define unlikely(expr) (__builtin_expect(expr, 0)) +#else +#define likely(expr) (expr) +#define unlikely(expr) (expr) +#endif +#endif + struct intel_sync_object { struct gl_sync_object Base; @@ -180,9 +190,6 @@ struct intel_context } prim; GLuint stats_wm; - GLboolean locked; - char *prevLockFile; - int prevLockLine; /* Offsets of fields within the current vertex: */ @@ -359,10 +366,15 @@ extern int INTEL_DEBUG; #define DEBUG_CLIP 0x8000000 #define DBG(...) do { \ - if (INTEL_DEBUG & FILE_DEBUG_FLAG) \ + if (unlikely(INTEL_DEBUG & FILE_DEBUG_FLAG)) \ printf(__VA_ARGS__); \ } while(0) +#define fallback_debug(...) do { \ + if (unlikely(INTEL_DEBUG & DEBUG_FALLBACKS)) \ + printf(__VA_ARGS__); \ +} while(0) + #define PCI_CHIP_845_G 0x2562 #define PCI_CHIP_I830_M 0x3577 #define PCI_CHIP_I855_GM 0x3582 diff --git a/src/mesa/drivers/dri/intel/intel_extensions.c b/src/mesa/drivers/dri/intel/intel_extensions.c index 974045730b..556a4195bd 100644 --- a/src/mesa/drivers/dri/intel/intel_extensions.c +++ b/src/mesa/drivers/dri/intel/intel_extensions.c @@ -55,6 +55,7 @@ #define need_GL_EXT_point_parameters #define need_GL_EXT_provoking_vertex #define need_GL_EXT_secondary_color +#define need_GL_EXT_separate_shader_objects #define need_GL_EXT_stencil_two_side #define need_GL_EXT_timer_query #define need_GL_APPLE_vertex_array_object @@ -114,6 +115,7 @@ static const struct dri_extension card_extensions[] = { { "GL_EXT_packed_depth_stencil", NULL }, { "GL_EXT_provoking_vertex", GL_EXT_provoking_vertex_functions }, { "GL_EXT_secondary_color", GL_EXT_secondary_color_functions }, + { "GL_EXT_separate_shader_objects", GL_EXT_separate_shader_objects_functions }, { "GL_EXT_stencil_wrap", NULL }, { "GL_EXT_texture_edge_clamp", NULL }, { "GL_EXT_texture_env_combine", NULL }, diff --git a/src/mesa/drivers/dri/intel/intel_pixel.c b/src/mesa/drivers/dri/intel/intel_pixel.c index 60583ef4c0..d5c35775ce 100644 --- a/src/mesa/drivers/dri/intel/intel_pixel.c +++ b/src/mesa/drivers/dri/intel/intel_pixel.c @@ -147,10 +147,9 @@ intel_check_blit_format(struct intel_region * region, return GL_TRUE; } - if (INTEL_DEBUG & DEBUG_PIXEL) - fprintf(stderr, "%s: bad format for blit (cpp %d, type %s format %s)\n", - __FUNCTION__, region->cpp, - _mesa_lookup_enum_by_nr(type), _mesa_lookup_enum_by_nr(format)); + DBG("%s: bad format for blit (cpp %d, type %s format %s)\n", + __FUNCTION__, region->cpp, + _mesa_lookup_enum_by_nr(type), _mesa_lookup_enum_by_nr(format)); return GL_FALSE; } diff --git a/src/mesa/drivers/dri/intel/intel_pixel_bitmap.c b/src/mesa/drivers/dri/intel/intel_pixel_bitmap.c index 63fb4b37b1..e7356a6da0 100644 --- a/src/mesa/drivers/dri/intel/intel_pixel_bitmap.c +++ b/src/mesa/drivers/dri/intel/intel_pixel_bitmap.c @@ -113,9 +113,8 @@ static GLuint get_bitmap_rect(GLsizei width, GLsizei height, GLint incr; GLuint count = 0; - if (INTEL_DEBUG & DEBUG_PIXEL) - printf("%s %d,%d %dx%d bitmap %dx%d skip %d src_offset %d mask %d\n", - __FUNCTION__, x,y,w,h,width,height,unpack->SkipPixels, src_offset, mask); + DBG("%s %d,%d %dx%d bitmap %dx%d skip %d src_offset %d mask %d\n", + __FUNCTION__, x,y,w,h,width,height,unpack->SkipPixels, src_offset, mask); if (invert) { first = h-1; @@ -285,7 +284,7 @@ do_blit_bitmap( struct gl_context *ctx, } out: - if (INTEL_DEBUG & DEBUG_SYNC) + if (unlikely(INTEL_DEBUG & DEBUG_SYNC)) intel_batchbuffer_flush(intel->batch); if (_mesa_is_bufferobj(unpack->BufferObj)) { @@ -299,6 +298,7 @@ out: return GL_TRUE; } + /* There are a large number of possible ways to implement bitmap on * this hardware, most of them have some sort of drawback. Here are a * few that spring to mind: diff --git a/src/mesa/drivers/dri/intel/intel_pixel_copy.c b/src/mesa/drivers/dri/intel/intel_pixel_copy.c index c6b36ed429..a7ca780e94 100644 --- a/src/mesa/drivers/dri/intel/intel_pixel_copy.c +++ b/src/mesa/drivers/dri/intel/intel_pixel_copy.c @@ -119,8 +119,7 @@ do_blit_copypixels(struct gl_context * ctx, GLboolean flip = GL_FALSE; if (type == GL_DEPTH || type == GL_STENCIL) { - if (INTEL_DEBUG & DEBUG_FALLBACKS) - fprintf(stderr, "glCopyPixels() fallback: GL_DEPTH || GL_STENCIL\n"); + fallback_debug("glCopyPixels() fallback: GL_DEPTH || GL_STENCIL\n"); return GL_FALSE; } @@ -203,8 +202,7 @@ intelCopyPixels(struct gl_context * ctx, GLsizei width, GLsizei height, GLint destx, GLint desty, GLenum type) { - if (INTEL_DEBUG & DEBUG_PIXEL) - fprintf(stderr, "%s\n", __FUNCTION__); + DBG("%s\n", __FUNCTION__); if (do_blit_copypixels(ctx, srcx, srcy, width, height, destx, desty, type)) return; diff --git a/src/mesa/drivers/dri/intel/intel_pixel_read.c b/src/mesa/drivers/dri/intel/intel_pixel_read.c index b249f9a5a0..54da29236d 100644 --- a/src/mesa/drivers/dri/intel/intel_pixel_read.c +++ b/src/mesa/drivers/dri/intel/intel_pixel_read.c @@ -42,6 +42,8 @@ #include "intel_pixel.h" #include "intel_buffer_objects.h" +#define FILE_DEBUG_FLAG DEBUG_PIXEL + /* For many applications, the new ability to pull the source buffers * back out of the GTT and then do the packing/conversion operations * in software will be as much of an improvement as trying to get the @@ -79,8 +81,7 @@ do_blit_readpixels(struct gl_context * ctx, GLboolean all; GLint dst_x, dst_y; - if (INTEL_DEBUG & DEBUG_PIXEL) - printf("%s\n", __FUNCTION__); + DBG("%s\n", __FUNCTION__); if (!src) return GL_FALSE; @@ -88,22 +89,19 @@ do_blit_readpixels(struct gl_context * ctx, if (!_mesa_is_bufferobj(pack->BufferObj)) { /* PBO only for now: */ - if (INTEL_DEBUG & DEBUG_PIXEL) - printf("%s - not PBO\n", __FUNCTION__); + DBG("%s - not PBO\n", __FUNCTION__); return GL_FALSE; } if (ctx->_ImageTransferState || !intel_check_blit_format(src, format, type)) { - if (INTEL_DEBUG & DEBUG_PIXEL) - printf("%s - bad format for blit\n", __FUNCTION__); + DBG("%s - bad format for blit\n", __FUNCTION__); return GL_FALSE; } if (pack->Alignment != 1 || pack->SwapBytes || pack->LsbFirst) { - if (INTEL_DEBUG & DEBUG_PIXEL) - printf("%s: bad packing params\n", __FUNCTION__); + DBG("%s: bad packing params\n", __FUNCTION__); return GL_FALSE; } @@ -113,8 +111,7 @@ do_blit_readpixels(struct gl_context * ctx, rowLength = width; if (pack->Invert) { - if (INTEL_DEBUG & DEBUG_PIXEL) - printf("%s: MESA_PACK_INVERT not done yet\n", __FUNCTION__); + DBG("%s: MESA_PACK_INVERT not done yet\n", __FUNCTION__); return GL_FALSE; } else { @@ -158,8 +155,7 @@ do_blit_readpixels(struct gl_context * ctx, return GL_FALSE; } - if (INTEL_DEBUG & DEBUG_PIXEL) - printf("%s - DONE\n", __FUNCTION__); + DBG("%s - DONE\n", __FUNCTION__); return GL_TRUE; } @@ -173,8 +169,7 @@ intelReadPixels(struct gl_context * ctx, struct intel_context *intel = intel_context(ctx); GLboolean dirty; - if (INTEL_DEBUG & DEBUG_PIXEL) - fprintf(stderr, "%s\n", __FUNCTION__); + DBG("%s\n", __FUNCTION__); intel_flush(ctx); @@ -188,8 +183,7 @@ intelReadPixels(struct gl_context * ctx, (ctx, x, y, width, height, format, type, pack, pixels)) return; - if (INTEL_DEBUG & DEBUG_PIXEL) - printf("%s: fallback to swrast\n", __FUNCTION__); + fallback_debug("%s: fallback to swrast\n", __FUNCTION__); /* Update Mesa state before calling down into _swrast_ReadPixels, as * the spans code requires the computed buffer states to be up to date, diff --git a/src/mesa/drivers/dri/intel/intel_tex.c b/src/mesa/drivers/dri/intel/intel_tex.c index 3d9a2549db..2c21ea0576 100644 --- a/src/mesa/drivers/dri/intel/intel_tex.c +++ b/src/mesa/drivers/dri/intel/intel_tex.c @@ -61,88 +61,6 @@ intelFreeTextureImageData(struct gl_context * ctx, struct gl_texture_image *texI } } - -/* The system memcpy (at least on ubuntu 5.10) has problems copying - * to agp (writecombined) memory from a source which isn't 64-byte - * aligned - there is a 4x performance falloff. - * - * The x86 __memcpy is immune to this but is slightly slower - * (10%-ish) than the system memcpy. - * - * The sse_memcpy seems to have a slight cliff at 64/32 bytes, but - * isn't much faster than x86_memcpy for agp copies. - * - * TODO: switch dynamically. - */ -static void * -do_memcpy(void *dest, const void *src, size_t n) -{ - if ((((unsigned long) src) & 63) || (((unsigned long) dest) & 63)) { - return __memcpy(dest, src, n); - } - else - return memcpy(dest, src, n); -} - - -#if DO_DEBUG && !defined(__ia64__) - -#ifndef __x86_64__ -static unsigned -fastrdtsc(void) -{ - unsigned eax; - __asm__ volatile ("\t" - "pushl %%ebx\n\t" - "cpuid\n\t" ".byte 0x0f, 0x31\n\t" - "popl %%ebx\n":"=a" (eax) - :"0"(0) - :"ecx", "edx", "cc"); - - return eax; -} -#else -static unsigned -fastrdtsc(void) -{ - unsigned eax; - __asm__ volatile ("\t" "cpuid\n\t" ".byte 0x0f, 0x31\n\t":"=a" (eax) - :"0"(0) - :"ecx", "edx", "ebx", "cc"); - - return eax; -} -#endif - -static unsigned -time_diff(unsigned t, unsigned t2) -{ - return ((t < t2) ? t2 - t : 0xFFFFFFFFU - (t - t2 - 1)); -} - - -static void * -timed_memcpy(void *dest, const void *src, size_t n) -{ - void *ret; - unsigned t1, t2; - double rate; - - if ((((unsigned) src) & 63) || (((unsigned) dest) & 63)) - printf("Warning - non-aligned texture copy!\n"); - - t1 = fastrdtsc(); - ret = do_memcpy(dest, src, n); - t2 = fastrdtsc(); - - rate = time_diff(t1, t2); - rate /= (double) n; - printf("timed_memcpy: %u %u --> %f clocks/byte\n", t1, t2, rate); - return ret; -} -#endif /* DO_DEBUG */ - - /** * Called via ctx->Driver.GenerateMipmap() * This is basically a wrapper for _mesa_meta_GenerateMipmap() which checks @@ -158,8 +76,7 @@ intelGenerateMipmap(struct gl_context *ctx, GLenum target, struct intel_context *intel = intel_context(ctx); struct intel_texture_object *intelObj = intel_texture_object(texObj); - if (INTEL_DEBUG & DEBUG_FALLBACKS) - fprintf(stderr, "%s - fallback to swrast\n", __FUNCTION__); + fallback_debug("%s - fallback to swrast\n", __FUNCTION__); intel_tex_map_level_images(intel, intelObj, texObj->BaseLevel); _mesa_generate_mipmap(ctx, target, texObj); @@ -203,11 +120,4 @@ intelInitTextureFuncs(struct dd_function_table *functions) functions->NewTextureImage = intelNewTextureImage; functions->DeleteTexture = intelDeleteTextureObject; functions->FreeTexImageData = intelFreeTextureImageData; - -#if DO_DEBUG && !defined(__ia64__) - if (INTEL_DEBUG & DEBUG_BUFMGR) - functions->TextureMemCpy = timed_memcpy; - else -#endif - functions->TextureMemCpy = do_memcpy; } diff --git a/src/mesa/drivers/dri/intel/intel_tex_copy.c b/src/mesa/drivers/dri/intel/intel_tex_copy.c index 2d046fd52d..87b31bf078 100644 --- a/src/mesa/drivers/dri/intel/intel_tex_copy.c +++ b/src/mesa/drivers/dri/intel/intel_tex_copy.c @@ -30,7 +30,6 @@ #include "main/image.h" #include "main/teximage.h" #include "main/texstate.h" -#include "main/mipmap.h" #include "drivers/common/meta.h" @@ -105,16 +104,15 @@ do_copy_texsubimage(struct intel_context *intel, const struct intel_region *src = get_teximage_source(intel, internalFormat); if (!intelImage->mt || !src || !src->buffer) { - if (INTEL_DEBUG & DEBUG_FALLBACKS) + if (unlikely(INTEL_DEBUG & DEBUG_FALLBACKS)) fprintf(stderr, "%s fail %p %p (0x%08x)\n", __FUNCTION__, intelImage->mt, src, internalFormat); return GL_FALSE; } if (intelImage->mt->cpp != src->cpp) { - if (INTEL_DEBUG & DEBUG_FALLBACKS) - fprintf(stderr, "%s fail %d vs %d cpp\n", - __FUNCTION__, intelImage->mt->cpp, src->cpp); + fallback_debug("%s fail %d vs %d cpp\n", + __FUNCTION__, intelImage->mt->cpp, src->cpp); return GL_FALSE; } @@ -212,8 +210,7 @@ intelCopyTexImage1D(struct gl_context * ctx, GLenum target, GLint level, return; fail: - if (INTEL_DEBUG & DEBUG_FALLBACKS) - fprintf(stderr, "%s - fallback to swrast\n", __FUNCTION__); + fallback_debug("%s - fallback to swrast\n", __FUNCTION__); _mesa_meta_CopyTexImage1D(ctx, target, level, internalFormat, x, y, width, border); } @@ -261,8 +258,7 @@ intelCopyTexImage2D(struct gl_context * ctx, GLenum target, GLint level, return; fail: - if (INTEL_DEBUG & DEBUG_FALLBACKS) - fprintf(stderr, "%s - fallback to swrast\n", __FUNCTION__); + fallback_debug("%s - fallback to swrast\n", __FUNCTION__); _mesa_meta_CopyTexImage2D(ctx, target, level, internalFormat, x, y, width, height, border); } @@ -287,8 +283,7 @@ intelCopyTexSubImage1D(struct gl_context * ctx, GLenum target, GLint level, if (!do_copy_texsubimage(intel_context(ctx), target, intel_texture_image(texImage), internalFormat, xoffset, 0, x, y, width, 1)) { - if (INTEL_DEBUG & DEBUG_FALLBACKS) - fprintf(stderr, "%s - fallback to swrast\n", __FUNCTION__); + fallback_debug("%s - fallback to swrast\n", __FUNCTION__); _mesa_meta_CopyTexSubImage1D(ctx, target, level, xoffset, x, y, width); } } @@ -314,8 +309,7 @@ intelCopyTexSubImage2D(struct gl_context * ctx, GLenum target, GLint level, internalFormat, xoffset, yoffset, x, y, width, height)) { - if (INTEL_DEBUG & DEBUG_FALLBACKS) - fprintf(stderr, "%s - fallback to swrast\n", __FUNCTION__); + fallback_debug("%s - fallback to swrast\n", __FUNCTION__); _mesa_meta_CopyTexSubImage2D(ctx, target, level, xoffset, yoffset, x, y, width, height); } diff --git a/src/mesa/drivers/dri/intel/intel_tex_image.c b/src/mesa/drivers/dri/intel/intel_tex_image.c index 35f3d7d382..41cdbfd2cb 100644 --- a/src/mesa/drivers/dri/intel/intel_tex_image.c +++ b/src/mesa/drivers/dri/intel/intel_tex_image.c @@ -66,7 +66,6 @@ guess_and_alloc_mipmap_tree(struct intel_context *intel, GLuint width = intelImage->base.Width; GLuint height = intelImage->base.Height; GLuint depth = intelImage->base.Depth; - GLuint l2width, l2height, l2depth; GLuint i, comp_byte = 0; GLuint texelBytes; @@ -114,10 +113,7 @@ guess_and_alloc_mipmap_tree(struct intel_context *intel, lastLevel = firstLevel; } else { - l2width = logbase2(width); - l2height = logbase2(height); - l2depth = logbase2(depth); - lastLevel = firstLevel + MAX2(MAX2(l2width, l2height), l2depth); + lastLevel = firstLevel + logbase2(MAX2(MAX2(width, height), depth)); } assert(!intelObj->mt); @@ -347,21 +343,6 @@ intelTexImage(struct gl_context * ctx, texImage->Data = NULL; } - /* If this is the only texture image in the tree, could call - * bmBufferData with NULL data to free the old block and avoid - * waiting on any outstanding fences. - */ - if (intelObj->mt && - intelObj->mt->first_level == level && - intelObj->mt->last_level == level && - intelObj->mt->target != GL_TEXTURE_CUBE_MAP_ARB && - !intel_miptree_match_image(intelObj->mt, &intelImage->base)) { - - DBG("release it\n"); - intel_miptree_release(intel, &intelObj->mt); - assert(!intelObj->mt); - } - if (!intelObj->mt) { guess_and_alloc_mipmap_tree(intel, intelObj, intelImage, pixels == NULL); if (!intelObj->mt) { @@ -701,6 +682,7 @@ intelSetTexBuffer2(__DRIcontext *pDRICtx, GLint target, struct gl_texture_object *texObj; struct gl_texture_image *texImage; int level = 0, internalFormat; + gl_format texFormat; texObj = _mesa_get_current_tex_object(ctx, target); intelObj = intel_texture_object(texObj); @@ -719,10 +701,14 @@ intelSetTexBuffer2(__DRIcontext *pDRICtx, GLint target, if (rb->region == NULL) return; - if (texture_format == __DRI_TEXTURE_FORMAT_RGB) + if (texture_format == __DRI_TEXTURE_FORMAT_RGB) { internalFormat = GL_RGB; - else + texFormat = MESA_FORMAT_XRGB8888; + } + else { internalFormat = GL_RGBA; + texFormat = MESA_FORMAT_ARGB8888; + } mt = intel_miptree_create_for_region(intel, target, internalFormat, @@ -743,16 +729,13 @@ intelSetTexBuffer2(__DRIcontext *pDRICtx, GLint target, intel_miptree_release(intel, &intelObj->mt); intelObj->mt = mt; + _mesa_init_teximage_fields(&intel->ctx, target, texImage, rb->region->width, rb->region->height, 1, - 0, internalFormat); + 0, internalFormat, texFormat); intelImage->face = target_to_face(target); intelImage->level = level; - if (texture_format == __DRI_TEXTURE_FORMAT_RGB) - texImage->TexFormat = MESA_FORMAT_XRGB8888; - else - texImage->TexFormat = MESA_FORMAT_ARGB8888; texImage->RowStride = rb->region->pitch; intel_miptree_reference(&intelImage->mt, intelObj->mt); @@ -808,11 +791,10 @@ intel_image_target_texture_2d(struct gl_context *ctx, GLenum target, intelObj->mt = mt; _mesa_init_teximage_fields(&intel->ctx, target, texImage, image->region->width, image->region->height, 1, - 0, image->internal_format); + 0, image->internal_format, image->format); intelImage->face = target_to_face(target); intelImage->level = 0; - texImage->TexFormat = image->format; texImage->RowStride = image->region->pitch; intel_miptree_reference(&intelImage->mt, intelObj->mt); diff --git a/src/mesa/drivers/dri/nouveau/Makefile b/src/mesa/drivers/dri/nouveau/Makefile index 7be19b26fd..3b506a91ff 100644 --- a/src/mesa/drivers/dri/nouveau/Makefile +++ b/src/mesa/drivers/dri/nouveau/Makefile @@ -19,6 +19,8 @@ DRIVER_SOURCES = \ nouveau_bo_state.c \ nouveau_texture.c \ nouveau_surface.c \ + nouveau_scratch.c \ + nouveau_array.c \ nv04_context.c \ nv04_render.c \ nv04_state_fb.c \ diff --git a/src/mesa/drivers/dri/nouveau/nouveau_array.c b/src/mesa/drivers/dri/nouveau/nouveau_array.c new file mode 100644 index 0000000000..17e6d163a0 --- /dev/null +++ b/src/mesa/drivers/dri/nouveau/nouveau_array.c @@ -0,0 +1,136 @@ +/* + * Copyright (C) 2009-2010 Francisco Jerez. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ + +#include "main/bufferobj.h" +#include "nouveau_driver.h" +#include "nouveau_array.h" +#include "nouveau_bufferobj.h" + +static void +get_array_extract(struct nouveau_array *a, extract_u_t *extract_u, + extract_f_t *extract_f) +{ +#define EXTRACT(in_t, out_t, k) \ + ({ \ + auto out_t f(struct nouveau_array *, int, int); \ + out_t f(struct nouveau_array *a, int i, int j) { \ + in_t x = ((in_t *)(a->buf + i * a->stride))[j]; \ + \ + return (out_t)x / (k); \ + }; \ + f; \ + }); + + switch (a->type) { + case GL_BYTE: + *extract_u = EXTRACT(char, unsigned, 1); + *extract_f = EXTRACT(char, float, SCHAR_MAX); + break; + case GL_UNSIGNED_BYTE: + *extract_u = EXTRACT(unsigned char, unsigned, 1); + *extract_f = EXTRACT(unsigned char, float, UCHAR_MAX); + break; + case GL_SHORT: + *extract_u = EXTRACT(short, unsigned, 1); + *extract_f = EXTRACT(short, float, SHRT_MAX); + break; + case GL_UNSIGNED_SHORT: + *extract_u = EXTRACT(unsigned short, unsigned, 1); + *extract_f = EXTRACT(unsigned short, float, USHRT_MAX); + break; + case GL_INT: + *extract_u = EXTRACT(int, unsigned, 1); + *extract_f = EXTRACT(int, float, INT_MAX); + break; + case GL_UNSIGNED_INT: + *extract_u = EXTRACT(unsigned int, unsigned, 1); + *extract_f = EXTRACT(unsigned int, float, UINT_MAX); + break; + case GL_FLOAT: + *extract_u = EXTRACT(float, unsigned, 1.0 / UINT_MAX); + *extract_f = EXTRACT(float, float, 1); + break; + default: + assert(0); + } +} + +void +nouveau_init_array(struct nouveau_array *a, int attr, int stride, + int fields, int type, struct gl_buffer_object *obj, + const void *ptr, GLboolean map) +{ + a->attr = attr; + a->stride = stride; + a->fields = fields; + a->type = type; + a->buf = NULL; + + if (obj) { + if (nouveau_bufferobj_hw(obj)) { + struct nouveau_bufferobj *nbo = + to_nouveau_bufferobj(obj); + + nouveau_bo_ref(nbo->bo, &a->bo); + a->offset = (intptr_t)ptr; + + if (map) { + nouveau_bo_map(a->bo, NOUVEAU_BO_RD); + a->buf = a->bo->map + a->offset; + } + + } else { + nouveau_bo_ref(NULL, &a->bo); + a->offset = 0; + + if (map) + a->buf = ADD_POINTERS( + nouveau_bufferobj_sys(obj), ptr); + } + } + + if (a->buf) + get_array_extract(a, &a->extract_u, &a->extract_f); +} + +void +nouveau_deinit_array(struct nouveau_array *a) +{ + if (a->bo) { + if (a->bo->map) + nouveau_bo_unmap(a->bo); + } + + a->buf = NULL; + a->fields = 0; +} + +void +nouveau_cleanup_array(struct nouveau_array *a) +{ + nouveau_deinit_array(a); + nouveau_bo_ref(NULL, &a->bo); +} diff --git a/src/mesa/drivers/dri/nouveau/nouveau_array.h b/src/mesa/drivers/dri/nouveau/nouveau_array.h new file mode 100644 index 0000000000..ad3d69b33d --- /dev/null +++ b/src/mesa/drivers/dri/nouveau/nouveau_array.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2009-2010 Francisco Jerez. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ + +#ifndef __NOUVEAU_ARRAY_H__ +#define __NOUVEAU_ARRAY_H__ + +struct nouveau_array; + +typedef unsigned (*extract_u_t)(struct nouveau_array *, int, int); +typedef float (*extract_f_t)(struct nouveau_array *, int, int); + +struct nouveau_array { + int attr; + int stride, fields, type; + + struct nouveau_bo *bo; + unsigned offset; + const void *buf; + + extract_u_t extract_u; + extract_f_t extract_f; +}; + +void +nouveau_init_array(struct nouveau_array *a, int attr, int stride, + int fields, int type, struct gl_buffer_object *obj, + const void *ptr, GLboolean map); + +void +nouveau_deinit_array(struct nouveau_array *a); + +void +nouveau_cleanup_array(struct nouveau_array *a); + +#endif diff --git a/src/mesa/drivers/dri/nouveau/nouveau_bo_state.c b/src/mesa/drivers/dri/nouveau/nouveau_bo_state.c index f31772fe1d..7eef8c1ee8 100644 --- a/src/mesa/drivers/dri/nouveau/nouveau_bo_state.c +++ b/src/mesa/drivers/dri/nouveau/nouveau_bo_state.c @@ -126,13 +126,13 @@ void nouveau_bo_context_reset(struct nouveau_bo_context *bctx) { struct nouveau_bo_state *s = &to_nouveau_context(bctx->ctx)->bo; - int i; - - for (i = 0; i < bctx->count; i++) - nouveau_bo_ref(NULL, &bctx->marker[i].bo); + int i, n = bctx->count; - s->count -= bctx->count; + s->count -= n; bctx->count = 0; + + for (i = 0; i < n; i++) + nouveau_bo_ref(NULL, &bctx->marker[i].bo); } GLboolean diff --git a/src/mesa/drivers/dri/nouveau/nouveau_bo_state.h b/src/mesa/drivers/dri/nouveau/nouveau_bo_state.h index 6119a8336e..388a16a56e 100644 --- a/src/mesa/drivers/dri/nouveau/nouveau_bo_state.h +++ b/src/mesa/drivers/dri/nouveau/nouveau_bo_state.h @@ -29,7 +29,7 @@ enum { NOUVEAU_BO_CONTEXT_FRAMEBUFFER = 0, - NOUVEAU_BO_CONTEXT_LMA_DEPTH, + NOUVEAU_BO_CONTEXT_HIERZ, NOUVEAU_BO_CONTEXT_SURFACE, NOUVEAU_BO_CONTEXT_TEXTURE0, NOUVEAU_BO_CONTEXT_TEXTURE1, diff --git a/src/mesa/drivers/dri/nouveau/nouveau_bufferobj.c b/src/mesa/drivers/dri/nouveau/nouveau_bufferobj.c index ad6e5bd805..e60b91f64b 100644 --- a/src/mesa/drivers/dri/nouveau/nouveau_bufferobj.c +++ b/src/mesa/drivers/dri/nouveau/nouveau_bufferobj.c @@ -30,6 +30,23 @@ #include "main/bufferobj.h" +static inline char * +get_bufferobj_map(struct gl_buffer_object *obj, unsigned flags) +{ + struct nouveau_bufferobj *nbo = to_nouveau_bufferobj(obj); + void *map = NULL; + + if (nbo->sys) { + map = nbo->sys; + } else if (nbo->bo) { + nouveau_bo_map(nbo->bo, flags); + map = nbo->bo->map; + nouveau_bo_unmap(nbo->bo); + } + + return map; +} + static struct gl_buffer_object * nouveau_bufferobj_new(struct gl_context *ctx, GLuint buffer, GLenum target) { @@ -50,6 +67,7 @@ nouveau_bufferobj_del(struct gl_context *ctx, struct gl_buffer_object *obj) struct nouveau_bufferobj *nbo = to_nouveau_bufferobj(obj); nouveau_bo_ref(NULL, &nbo->bo); + FREE(nbo->sys); FREE(nbo); } @@ -64,18 +82,27 @@ nouveau_bufferobj_data(struct gl_context *ctx, GLenum target, GLsizeiptrARB size obj->Size = size; obj->Usage = usage; + /* Free previous storage */ nouveau_bo_ref(NULL, &nbo->bo); - ret = nouveau_bo_new(context_dev(ctx), - NOUVEAU_BO_GART | NOUVEAU_BO_MAP, 0, - size, &nbo->bo); - assert(!ret); - - if (data) { - nouveau_bo_map(nbo->bo, NOUVEAU_BO_WR); - memcpy(nbo->bo->map, data, size); - nouveau_bo_unmap(nbo->bo); + FREE(nbo->sys); + + if (target == GL_ELEMENT_ARRAY_BUFFER_ARB || + (size < 512 && usage == GL_DYNAMIC_DRAW_ARB) || + context_chipset(ctx) < 0x10) { + /* Heuristic: keep it in system ram */ + nbo->sys = MALLOC(size); + + } else { + /* Get a hardware BO */ + ret = nouveau_bo_new(context_dev(ctx), + NOUVEAU_BO_GART | NOUVEAU_BO_MAP, 0, + size, &nbo->bo); + assert(!ret); } + if (data) + memcpy(get_bufferobj_map(obj, NOUVEAU_BO_WR), data, size); + return GL_TRUE; } @@ -84,11 +111,7 @@ nouveau_bufferobj_subdata(struct gl_context *ctx, GLenum target, GLintptrARB off GLsizeiptrARB size, const GLvoid *data, struct gl_buffer_object *obj) { - struct nouveau_bufferobj *nbo = to_nouveau_bufferobj(obj); - - nouveau_bo_map(nbo->bo, NOUVEAU_BO_WR); - memcpy(nbo->bo->map + offset, data, size); - nouveau_bo_unmap(nbo->bo); + memcpy(get_bufferobj_map(obj, NOUVEAU_BO_WR) + offset, data, size); } static void @@ -96,44 +119,48 @@ nouveau_bufferobj_get_subdata(struct gl_context *ctx, GLenum target, GLintptrARB GLsizeiptrARB size, GLvoid *data, struct gl_buffer_object *obj) { - struct nouveau_bufferobj *nbo = to_nouveau_bufferobj(obj); - - nouveau_bo_map(nbo->bo, NOUVEAU_BO_RD); - memcpy(data, nbo->bo->map + offset, size); - nouveau_bo_unmap(nbo->bo); + memcpy(data, get_bufferobj_map(obj, NOUVEAU_BO_RD) + offset, size); } static void * nouveau_bufferobj_map(struct gl_context *ctx, GLenum target, GLenum access, struct gl_buffer_object *obj) { - return ctx->Driver.MapBufferRange(ctx, target, 0, obj->Size, access, + unsigned flags = 0; + + if (access == GL_READ_ONLY_ARB || + access == GL_READ_WRITE_ARB) + flags |= GL_MAP_READ_BIT; + if (access == GL_WRITE_ONLY_ARB || + access == GL_READ_WRITE_ARB) + flags |= GL_MAP_WRITE_BIT; + + return ctx->Driver.MapBufferRange(ctx, target, 0, obj->Size, flags, obj); } static void * nouveau_bufferobj_map_range(struct gl_context *ctx, GLenum target, GLintptr offset, - GLsizeiptr length, GLenum access, + GLsizeiptr length, GLbitfield access, struct gl_buffer_object *obj) { - struct nouveau_bufferobj *nbo = to_nouveau_bufferobj(obj); - uint32_t flags = 0; + unsigned flags = 0; + char *map; assert(!obj->Pointer); - if (!nbo->bo) - return NULL; - - if (access == GL_READ_ONLY_ARB || - access == GL_READ_WRITE_ARB) + if (access & GL_MAP_READ_BIT) flags |= NOUVEAU_BO_RD; - if (access == GL_WRITE_ONLY_ARB || - access == GL_READ_WRITE_ARB) + if (access & GL_MAP_WRITE_BIT) flags |= NOUVEAU_BO_WR; + if (access & GL_MAP_UNSYNCHRONIZED_BIT) + flags |= NOUVEAU_BO_NOSYNC; - nouveau_bo_map_range(nbo->bo, offset, length, flags); + map = get_bufferobj_map(obj, flags); + if (!map) + return NULL; - obj->Pointer = nbo->bo->map; + obj->Pointer = map + offset; obj->Offset = offset; obj->Length = length; obj->AccessFlags = access; @@ -144,12 +171,8 @@ nouveau_bufferobj_map_range(struct gl_context *ctx, GLenum target, GLintptr offs static GLboolean nouveau_bufferobj_unmap(struct gl_context *ctx, GLenum target, struct gl_buffer_object *obj) { - struct nouveau_bufferobj *nbo = to_nouveau_bufferobj(obj); - assert(obj->Pointer); - nouveau_bo_unmap(nbo->bo); - obj->Pointer = NULL; obj->Offset = 0; obj->Length = 0; diff --git a/src/mesa/drivers/dri/nouveau/nouveau_bufferobj.h b/src/mesa/drivers/dri/nouveau/nouveau_bufferobj.h index acfc4cb9a9..01ef0bad0f 100644 --- a/src/mesa/drivers/dri/nouveau/nouveau_bufferobj.h +++ b/src/mesa/drivers/dri/nouveau/nouveau_bufferobj.h @@ -30,9 +30,16 @@ struct nouveau_bufferobj { struct gl_buffer_object base; struct nouveau_bo *bo; + void *sys; }; #define to_nouveau_bufferobj(x) ((struct nouveau_bufferobj *)(x)) +#define nouveau_bufferobj_hw(x) \ + (_mesa_is_bufferobj(x) ? to_nouveau_bufferobj(x)->bo : NULL) + +#define nouveau_bufferobj_sys(x) \ + (_mesa_is_bufferobj(x) ? to_nouveau_bufferobj(x)->sys : NULL) + void nouveau_bufferobj_functions_init(struct dd_function_table *functions); diff --git a/src/mesa/drivers/dri/nouveau/nouveau_class.h b/src/mesa/drivers/dri/nouveau/nouveau_class.h deleted file mode 100644 index d41d431f79..0000000000 --- a/src/mesa/drivers/dri/nouveau/nouveau_class.h +++ /dev/null @@ -1,4959 +0,0 @@ -/************************************************************************* - - Autogenerated file, do not edit ! - - This file was generated by renouveau-gen from renouveau.xml, the - XML database of nvidia objects and methods. renouveau-gen and - renouveau.xml can be found in CVS module renouveau of sourceforge.net - project nouveau: - -cvs -z3 -d:pserver:anonymous@nouveau.cvs.sourceforge.net:/cvsroot/nouveau co -P renouveau - -************************************************************************** - - Copyright (C) 2006-2008 : - Dmitry Baryshkov, - Laurent Carlier, - Matthieu Castet, - Dawid Gajownik, - Jeremy Kolb, - Stephane Loeuillet, - Patrice Mandin, - Stephane Marchesin, - Serge Martin, - Sylvain Munaut, - Simon Raffeiner, - Ben Skeggs, - Erik Waling, - koala_br, - -All Rights Reserved. - -Permission is hereby granted, free of charge, to any person obtaining -a copy of this software and associated documentation files (the -"Software"), to deal in the Software without restriction, including -without limitation the rights to use, copy, modify, merge, publish, -distribute, sublicense, and/or sell copies of the Software, and to -permit persons to whom the Software is furnished to do so, subject to -the following conditions: - -The above copyright notice and this permission notice (including the -next paragraph) shall be included in all copies or substantial -portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE -LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - -*************************************************************************/ - - -#ifndef NOUVEAU_REG_H -#define NOUVEAU_REG_H 1 - - -#define NV01_ROOT 0x00000001 - - - -#define NV01_CONTEXT_DMA 0x00000002 - - - -#define NV01_DEVICE 0x00000003 - - - -#define NV01_TIMER 0x00000004 - -#define NV01_TIMER_SYNCHRONIZE 0x00000100 -#define NV01_TIMER_STOP_ALARM 0x00000104 -#define NV01_TIMER_DMA_NOTIFY 0x00000180 -#define NV01_TIMER_TIME(x) (0x00000300+((x)*4)) -#define NV01_TIMER_TIME__SIZE 0x00000002 -#define NV01_TIMER_ALARM_NOTIFY 0x00000308 - - -#define NV01_CONTEXT_BETA1 0x00000012 - -#define NV01_CONTEXT_BETA1_NOP 0x00000100 -#define NV01_CONTEXT_BETA1_NOTIFY 0x00000104 -#define NV01_CONTEXT_BETA1_DMA_NOTIFY 0x00000180 -#define NV01_CONTEXT_BETA1_BETA_1D31 0x00000300 - - -#define NV01_CONTEXT_COLOR_KEY 0x00000017 - -#define NV01_CONTEXT_COLOR_KEY_NOP 0x00000100 -#define NV01_CONTEXT_COLOR_KEY_NOTIFY 0x00000104 -#define NV01_CONTEXT_COLOR_KEY_DMA_NOTIFY 0x00000180 -#define NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT 0x00000300 -#define NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_X16A8Y8 0x00000001 -#define NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_X24Y8 0x00000002 -#define NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_X16A1R5G5B5 0x00000003 -#define NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_X17R5G5B5 0x00000004 -#define NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_A8R8G8B8 0x00000005 -#define NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_X8R8G8B8 0x00000006 -#define NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_A16Y16 0x00000007 -#define NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_X16Y16 0x00000008 -#define NV01_CONTEXT_COLOR_KEY_COLOR 0x00000304 - - -#define NV04_CONTEXT_COLOR_KEY 0x00000057 - - - -#define NV01_CONTEXT_PATTERN 0x00000018 - -#define NV01_CONTEXT_PATTERN_NOP 0x00000100 -#define NV01_CONTEXT_PATTERN_NOTIFY 0x00000104 -#define NV01_CONTEXT_PATTERN_DMA_NOTIFY 0x00000180 -#define NV01_CONTEXT_PATTERN_COLOR_FORMAT 0x00000300 -#define NV01_CONTEXT_PATTERN_MONOCHROME_FORMAT 0x00000304 -#define NV01_CONTEXT_PATTERN_SHAPE 0x00000308 -#define NV01_CONTEXT_PATTERN_COLOR(x) (0x00000310+((x)*4)) -#define NV01_CONTEXT_PATTERN_COLOR__SIZE 0x00000002 -#define NV01_CONTEXT_PATTERN_PATTERN(x) (0x00000318+((x)*4)) -#define NV01_CONTEXT_PATTERN_PATTERN__SIZE 0x00000002 - - -#define NV01_CONTEXT_CLIP_RECTANGLE 0x00000019 - -#define NV01_CONTEXT_CLIP_RECTANGLE_NOP 0x00000100 -#define NV01_CONTEXT_CLIP_RECTANGLE_NOTIFY 0x00000104 -#define NV01_CONTEXT_CLIP_RECTANGLE_DMA_NOTIFY 0x00000180 -#define NV01_CONTEXT_CLIP_RECTANGLE_POINT 0x00000300 -#define NV01_CONTEXT_CLIP_RECTANGLE_POINT_X_SHIFT 0 -#define NV01_CONTEXT_CLIP_RECTANGLE_POINT_X_MASK 0x0000ffff -#define NV01_CONTEXT_CLIP_RECTANGLE_POINT_Y_SHIFT 16 -#define NV01_CONTEXT_CLIP_RECTANGLE_POINT_Y_MASK 0xffff0000 -#define NV01_CONTEXT_CLIP_RECTANGLE_SIZE 0x00000304 -#define NV01_CONTEXT_CLIP_RECTANGLE_SIZE_W_SHIFT 0 -#define NV01_CONTEXT_CLIP_RECTANGLE_SIZE_W_MASK 0x0000ffff -#define NV01_CONTEXT_CLIP_RECTANGLE_SIZE_H_SHIFT 16 -#define NV01_CONTEXT_CLIP_RECTANGLE_SIZE_H_MASK 0xffff0000 - - -#define NV01_RENDER_SOLID_LINE 0x0000001c - -#define NV01_RENDER_SOLID_LINE_NOP 0x00000100 -#define NV01_RENDER_SOLID_LINE_NOTIFY 0x00000104 -#define NV01_RENDER_SOLID_LINE_PATCH 0x0000010c -#define NV01_RENDER_SOLID_LINE_DMA_NOTIFY 0x00000180 -#define NV01_RENDER_SOLID_LINE_CLIP_RECTANGLE 0x00000184 -#define NV01_RENDER_SOLID_LINE_PATTERN 0x00000188 -#define NV01_RENDER_SOLID_LINE_ROP 0x0000018c -#define NV01_RENDER_SOLID_LINE_BETA1 0x00000190 -#define NV01_RENDER_SOLID_LINE_SURFACE 0x00000194 -#define NV01_RENDER_SOLID_LINE_OPERATION 0x000002fc -#define NV01_RENDER_SOLID_LINE_OPERATION_SRCCOPY_AND 0x00000000 -#define NV01_RENDER_SOLID_LINE_OPERATION_ROP_AND 0x00000001 -#define NV01_RENDER_SOLID_LINE_OPERATION_BLEND_AND 0x00000002 -#define NV01_RENDER_SOLID_LINE_OPERATION_SRCCOPY 0x00000003 -#define NV01_RENDER_SOLID_LINE_OPERATION_SRCCOPY_PREMULT 0x00000004 -#define NV01_RENDER_SOLID_LINE_OPERATION_BLEND_PREMULT 0x00000005 -#define NV01_RENDER_SOLID_LINE_COLOR_FORMAT 0x00000300 -#define NV01_RENDER_SOLID_LINE_COLOR_FORMAT_X16A8Y8 0x00000001 -#define NV01_RENDER_SOLID_LINE_COLOR_FORMAT_X24Y8 0x00000002 -#define NV01_RENDER_SOLID_LINE_COLOR_FORMAT_X16A1R5G5B5 0x00000003 -#define NV01_RENDER_SOLID_LINE_COLOR_FORMAT_X17R5G5B5 0x00000004 -#define NV01_RENDER_SOLID_LINE_COLOR_FORMAT_A8R8G8B8 0x00000005 -#define NV01_RENDER_SOLID_LINE_COLOR_FORMAT_X8R8G8B8 0x00000006 -#define NV01_RENDER_SOLID_LINE_COLOR_FORMAT_A16Y16 0x00000007 -#define NV01_RENDER_SOLID_LINE_COLOR_FORMAT_X16Y16 0x00000008 -#define NV01_RENDER_SOLID_LINE_COLOR 0x00000304 -#define NV01_RENDER_SOLID_LINE_LINE_POINT0(x) (0x00000400+((x)*8)) -#define NV01_RENDER_SOLID_LINE_LINE_POINT0__SIZE 0x00000010 -#define NV01_RENDER_SOLID_LINE_LINE_POINT0_X_SHIFT 0 -#define NV01_RENDER_SOLID_LINE_LINE_POINT0_X_MASK 0x0000ffff -#define NV01_RENDER_SOLID_LINE_LINE_POINT0_Y_SHIFT 16 -#define NV01_RENDER_SOLID_LINE_LINE_POINT0_Y_MASK 0xffff0000 -#define NV01_RENDER_SOLID_LINE_LINE_POINT1(x) (0x00000404+((x)*8)) -#define NV01_RENDER_SOLID_LINE_LINE_POINT1__SIZE 0x00000010 -#define NV01_RENDER_SOLID_LINE_LINE_POINT1_X_SHIFT 0 -#define NV01_RENDER_SOLID_LINE_LINE_POINT1_X_MASK 0x0000ffff -#define NV01_RENDER_SOLID_LINE_LINE_POINT1_Y_SHIFT 16 -#define NV01_RENDER_SOLID_LINE_LINE_POINT1_Y_MASK 0xffff0000 -#define NV01_RENDER_SOLID_LINE_LINE32_POINT0_X(x) (0x00000480+((x)*16)) -#define NV01_RENDER_SOLID_LINE_LINE32_POINT0_X__SIZE 0x00000010 -#define NV01_RENDER_SOLID_LINE_LINE32_POINT0_Y(x) (0x00000484+((x)*16)) -#define NV01_RENDER_SOLID_LINE_LINE32_POINT0_Y__SIZE 0x00000010 -#define NV01_RENDER_SOLID_LINE_LINE32_POINT1_X(x) (0x00000488+((x)*16)) -#define NV01_RENDER_SOLID_LINE_LINE32_POINT1_X__SIZE 0x00000010 -#define NV01_RENDER_SOLID_LINE_LINE32_POINT1_Y(x) (0x0000048c+((x)*16)) -#define NV01_RENDER_SOLID_LINE_LINE32_POINT1_Y__SIZE 0x00000010 -#define NV01_RENDER_SOLID_LINE_POLYLINE(x) (0x00000500+((x)*4)) -#define NV01_RENDER_SOLID_LINE_POLYLINE__SIZE 0x00000020 -#define NV01_RENDER_SOLID_LINE_POLYLINE_X_SHIFT 0 -#define NV01_RENDER_SOLID_LINE_POLYLINE_X_MASK 0x0000ffff -#define NV01_RENDER_SOLID_LINE_POLYLINE_Y_SHIFT 16 -#define NV01_RENDER_SOLID_LINE_POLYLINE_Y_MASK 0xffff0000 -#define NV01_RENDER_SOLID_LINE_POLYLINE32_POINT_X(x) (0x00000580+((x)*8)) -#define NV01_RENDER_SOLID_LINE_POLYLINE32_POINT_X__SIZE 0x00000010 -#define NV01_RENDER_SOLID_LINE_POLYLINE32_POINT_Y(x) (0x00000584+((x)*8)) -#define NV01_RENDER_SOLID_LINE_POLYLINE32_POINT_Y__SIZE 0x00000010 -#define NV01_RENDER_SOLID_LINE_CPOLYLINE_COLOR(x) (0x00000600+((x)*8)) -#define NV01_RENDER_SOLID_LINE_CPOLYLINE_COLOR__SIZE 0x00000010 -#define NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT(x) (0x00000604+((x)*8)) -#define NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT__SIZE 0x00000010 -#define NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT_X_SHIFT 0 -#define NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT_X_MASK 0x0000ffff -#define NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT_Y_SHIFT 16 -#define NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT_Y_MASK 0xffff0000 - - -#define NV04_RENDER_SOLID_LINE 0x0000005c - -#define NV04_RENDER_SOLID_LINE_BETA4 0x00000194 -#define NV04_RENDER_SOLID_LINE_SURFACE 0x00000198 - - -#define NV01_RENDER_SOLID_TRIANGLE 0x0000001d - -#define NV01_RENDER_SOLID_TRIANGLE_NOP 0x00000100 -#define NV01_RENDER_SOLID_TRIANGLE_NOTIFY 0x00000104 -#define NV01_RENDER_SOLID_TRIANGLE_PATCH 0x0000010c -#define NV01_RENDER_SOLID_TRIANGLE_DMA_NOTIFY 0x00000180 -#define NV01_RENDER_SOLID_TRIANGLE_CLIP_RECTANGLE 0x00000184 -#define NV01_RENDER_SOLID_TRIANGLE_PATTERN 0x00000188 -#define NV01_RENDER_SOLID_TRIANGLE_ROP 0x0000018c -#define NV01_RENDER_SOLID_TRIANGLE_BETA1 0x00000190 -#define NV01_RENDER_SOLID_TRIANGLE_SURFACE 0x00000194 -#define NV01_RENDER_SOLID_TRIANGLE_OPERATION 0x000002fc -#define NV01_RENDER_SOLID_TRIANGLE_OPERATION_SRCCOPY_AND 0x00000000 -#define NV01_RENDER_SOLID_TRIANGLE_OPERATION_ROP_AND 0x00000001 -#define NV01_RENDER_SOLID_TRIANGLE_OPERATION_BLEND_AND 0x00000002 -#define NV01_RENDER_SOLID_TRIANGLE_OPERATION_SRCCOPY 0x00000003 -#define NV01_RENDER_SOLID_TRIANGLE_OPERATION_SRCCOPY_PREMULT 0x00000004 -#define NV01_RENDER_SOLID_TRIANGLE_OPERATION_BLEND_PREMULT 0x00000005 -#define NV01_RENDER_SOLID_TRIANGLE_COLOR_FORMAT 0x00000300 -#define NV01_RENDER_SOLID_TRIANGLE_COLOR 0x00000304 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT0 0x00000310 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT0_X_SHIFT 0 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT0_X_MASK 0x0000ffff -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT0_Y_SHIFT 16 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT0_Y_MASK 0xffff0000 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT1 0x00000314 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT1_X_SHIFT 0 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT1_X_MASK 0x0000ffff -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT1_Y_SHIFT 16 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT1_Y_MASK 0xffff0000 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT2 0x00000318 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT2_X_SHIFT 0 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT2_X_MASK 0x0000ffff -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT2_Y_SHIFT 16 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT2_Y_MASK 0xffff0000 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT0_X 0x00000320 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT0_Y 0x00000324 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT1_X 0x00000328 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT1_Y 0x0000032c -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT2_X 0x00000330 -#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT2_Y 0x00000334 -#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH(x) (0x00000400+((x)*4)) -#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH__SIZE 0x00000020 -#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH_X_SHIFT 0 -#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH_X_MASK 0x0000ffff -#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH_Y_SHIFT 16 -#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH_Y_MASK 0xffff0000 -#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH32_POINT_X(x) (0x00000480+((x)*8)) -#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH32_POINT_X__SIZE 0x00000010 -#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH32_POINT_Y(x) (0x00000484+((x)*8)) -#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH32_POINT_Y__SIZE 0x00000010 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_COLOR(x) (0x00000500+((x)*16)) -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_COLOR__SIZE 0x00000008 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0(x) (0x00000504+((x)*16)) -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0__SIZE 0x00000008 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0_X_SHIFT 0 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0_X_MASK 0x0000ffff -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0_Y_SHIFT 16 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0_Y_MASK 0xffff0000 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1(x) (0x00000508+((x)*16)) -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1__SIZE 0x00000008 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1_X_SHIFT 0 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1_X_MASK 0x0000ffff -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1_Y_SHIFT 16 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1_Y_MASK 0xffff0000 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2(x) (0x0000050c+((x)*16)) -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2__SIZE 0x00000008 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2_X_SHIFT 0 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2_X_MASK 0x0000ffff -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2_Y_SHIFT 16 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2_Y_MASK 0xffff0000 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_COLOR(x) (0x00000580+((x)*8)) -#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_COLOR__SIZE 0x00000010 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT(x) (0x00000584+((x)*8)) -#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT__SIZE 0x00000010 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT_X_SHIFT 0 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT_X_MASK 0x0000ffff -#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT_Y_SHIFT 16 -#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT_Y_MASK 0xffff0000 - - -#define NV04_RENDER_SOLID_TRIANGLE 0x0000005d - -#define NV04_RENDER_SOLID_TRIANGLE_BETA4 0x00000194 -#define NV04_RENDER_SOLID_TRIANGLE_SURFACE 0x00000198 - - -#define NV01_RENDER_SOLID_RECTANGLE 0x0000001e - -#define NV01_RENDER_SOLID_RECTANGLE_NOP 0x00000100 -#define NV01_RENDER_SOLID_RECTANGLE_NOTIFY 0x00000104 -#define NV01_RENDER_SOLID_RECTANGLE_PATCH 0x0000010c -#define NV01_RENDER_SOLID_RECTANGLE_DMA_NOTIFY 0x00000180 -#define NV01_RENDER_SOLID_RECTANGLE_CLIP_RECTANGLE 0x00000184 -#define NV01_RENDER_SOLID_RECTANGLE_PATTERN 0x00000188 -#define NV01_RENDER_SOLID_RECTANGLE_ROP 0x0000018c -#define NV01_RENDER_SOLID_RECTANGLE_BETA1 0x00000190 -#define NV01_RENDER_SOLID_RECTANGLE_SURFACE 0x00000194 -#define NV01_RENDER_SOLID_RECTANGLE_OPERATION 0x000002fc -#define NV01_RENDER_SOLID_RECTANGLE_OPERATION_SRCCOPY_AND 0x00000000 -#define NV01_RENDER_SOLID_RECTANGLE_OPERATION_ROP_AND 0x00000001 -#define NV01_RENDER_SOLID_RECTANGLE_OPERATION_BLEND_AND 0x00000002 -#define NV01_RENDER_SOLID_RECTANGLE_OPERATION_SRCCOPY 0x00000003 -#define NV01_RENDER_SOLID_RECTANGLE_OPERATION_SRCCOPY_PREMULT 0x00000004 -#define NV01_RENDER_SOLID_RECTANGLE_OPERATION_BLEND_PREMULT 0x00000005 -#define NV01_RENDER_SOLID_RECTANGLE_COLOR_FORMAT 0x00000300 -#define NV01_RENDER_SOLID_RECTANGLE_COLOR 0x00000304 -#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT(x) (0x00000400+((x)*8)) -#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT__SIZE 0x00000010 -#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT_X_SHIFT 0 -#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT_X_MASK 0x0000ffff -#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT_Y_SHIFT 16 -#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT_Y_MASK 0xffff0000 -#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE(x) (0x00000404+((x)*8)) -#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE__SIZE 0x00000010 -#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE_W_SHIFT 0 -#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE_W_MASK 0x0000ffff -#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE_H_SHIFT 16 -#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE_H_MASK 0xffff0000 - - -#define NV04_RENDER_SOLID_RECTANGLE 0x0000005e - -#define NV04_RENDER_SOLID_RECTANGLE_BETA4 0x00000194 -#define NV04_RENDER_SOLID_RECTANGLE_SURFACE 0x00000198 - - -#define NV01_IMAGE_BLIT 0x0000001f - -#define NV01_IMAGE_BLIT_NOP 0x00000100 -#define NV01_IMAGE_BLIT_NOTIFY 0x00000104 -#define NV01_IMAGE_BLIT_PATCH 0x0000010c -#define NV01_IMAGE_BLIT_DMA_NOTIFY 0x00000180 -#define NV01_IMAGE_BLIT_COLOR_KEY 0x00000184 -#define NV01_IMAGE_BLIT_CLIP_RECTANGLE 0x00000188 -#define NV01_IMAGE_BLIT_PATTERN 0x0000018c -#define NV01_IMAGE_BLIT_ROP 0x00000190 -#define NV01_IMAGE_BLIT_BETA1 0x00000194 -#define NV01_IMAGE_BLIT_SURFACE 0x0000019c -#define NV01_IMAGE_BLIT_OPERATION 0x000002fc -#define NV01_IMAGE_BLIT_OPERATION_SRCCOPY_AND 0x00000000 -#define NV01_IMAGE_BLIT_OPERATION_ROP_AND 0x00000001 -#define NV01_IMAGE_BLIT_OPERATION_BLEND_AND 0x00000002 -#define NV01_IMAGE_BLIT_OPERATION_SRCCOPY 0x00000003 -#define NV01_IMAGE_BLIT_OPERATION_SRCCOPY_PREMULT 0x00000004 -#define NV01_IMAGE_BLIT_OPERATION_BLEND_PREMULT 0x00000005 -#define NV01_IMAGE_BLIT_IMAGE_INPUT 0x00000204 -#define NV01_IMAGE_BLIT_POINT_IN 0x00000300 -#define NV01_IMAGE_BLIT_POINT_IN_X_SHIFT 0 -#define NV01_IMAGE_BLIT_POINT_IN_X_MASK 0x0000ffff -#define NV01_IMAGE_BLIT_POINT_IN_Y_SHIFT 16 -#define NV01_IMAGE_BLIT_POINT_IN_Y_MASK 0xffff0000 -#define NV01_IMAGE_BLIT_POINT_OUT 0x00000304 -#define NV01_IMAGE_BLIT_POINT_OUT_X_SHIFT 0 -#define NV01_IMAGE_BLIT_POINT_OUT_X_MASK 0x0000ffff -#define NV01_IMAGE_BLIT_POINT_OUT_Y_SHIFT 16 -#define NV01_IMAGE_BLIT_POINT_OUT_Y_MASK 0xffff0000 -#define NV01_IMAGE_BLIT_SIZE 0x00000308 -#define NV01_IMAGE_BLIT_SIZE_W_SHIFT 0 -#define NV01_IMAGE_BLIT_SIZE_W_MASK 0x0000ffff -#define NV01_IMAGE_BLIT_SIZE_H_SHIFT 16 -#define NV01_IMAGE_BLIT_SIZE_H_MASK 0xffff0000 - - -#define NV04_IMAGE_BLIT 0x0000005f - -#define NV04_IMAGE_BLIT_ROP 0x00000190 -#define NV04_IMAGE_BLIT_BETA4 0x00000198 -#define NV04_IMAGE_BLIT_SURFACE 0x0000019c - - -#define NV12_IMAGE_BLIT 0x0000009f - -#define NV12_IMAGE_BLIT_WAIT_FOR_IDLE 0x00000108 - - -#define NV01_IMAGE_FROM_CPU 0x00000021 - -#define NV01_IMAGE_FROM_CPU_NOP 0x00000100 -#define NV01_IMAGE_FROM_CPU_NOTIFY 0x00000104 -#define NV01_IMAGE_FROM_CPU_PATCH 0x0000010c -#define NV01_IMAGE_FROM_CPU_DMA_NOTIFY 0x00000180 -#define NV01_IMAGE_FROM_CPU_COLOR_KEY 0x00000184 -#define NV01_IMAGE_FROM_CPU_CLIP_RECTANGLE 0x00000188 -#define NV01_IMAGE_FROM_CPU_PATTERN 0x0000018c -#define NV01_IMAGE_FROM_CPU_ROP 0x00000190 -#define NV01_IMAGE_FROM_CPU_BETA1 0x00000194 -#define NV01_IMAGE_FROM_CPU_SURFACE 0x00000198 -#define NV01_IMAGE_FROM_CPU_OPERATION 0x000002fc -#define NV01_IMAGE_FROM_CPU_OPERATION_SRCCOPY_AND 0x00000000 -#define NV01_IMAGE_FROM_CPU_OPERATION_ROP_AND 0x00000001 -#define NV01_IMAGE_FROM_CPU_OPERATION_BLEND_AND 0x00000002 -#define NV01_IMAGE_FROM_CPU_OPERATION_SRCCOPY 0x00000003 -#define NV01_IMAGE_FROM_CPU_OPERATION_SRCCOPY_PREMULT 0x00000004 -#define NV01_IMAGE_FROM_CPU_OPERATION_BLEND_PREMULT 0x00000005 -#define NV01_IMAGE_FROM_CPU_COLOR_FORMAT 0x00000300 -#define NV01_IMAGE_FROM_CPU_COLOR_FORMAT_Y8 0x00000001 -#define NV01_IMAGE_FROM_CPU_COLOR_FORMAT_A1R5G5B5 0x00000002 -#define NV01_IMAGE_FROM_CPU_COLOR_FORMAT_X1R5G5B5 0x00000003 -#define NV01_IMAGE_FROM_CPU_COLOR_FORMAT_A8R8G8B8 0x00000004 -#define NV01_IMAGE_FROM_CPU_COLOR_FORMAT_X8R8G8B8 0x00000005 -#define NV01_IMAGE_FROM_CPU_POINT 0x00000304 -#define NV01_IMAGE_FROM_CPU_POINT_X_SHIFT 0 -#define NV01_IMAGE_FROM_CPU_POINT_X_MASK 0x0000ffff -#define NV01_IMAGE_FROM_CPU_POINT_Y_SHIFT 16 -#define NV01_IMAGE_FROM_CPU_POINT_Y_MASK 0xffff0000 -#define NV01_IMAGE_FROM_CPU_SIZE_OUT 0x00000308 -#define NV01_IMAGE_FROM_CPU_SIZE_OUT_W_SHIFT 0 -#define NV01_IMAGE_FROM_CPU_SIZE_OUT_W_MASK 0x0000ffff -#define NV01_IMAGE_FROM_CPU_SIZE_OUT_H_SHIFT 16 -#define NV01_IMAGE_FROM_CPU_SIZE_OUT_H_MASK 0xffff0000 -#define NV01_IMAGE_FROM_CPU_SIZE_IN 0x0000030c -#define NV01_IMAGE_FROM_CPU_SIZE_IN_W_SHIFT 0 -#define NV01_IMAGE_FROM_CPU_SIZE_IN_W_MASK 0x0000ffff -#define NV01_IMAGE_FROM_CPU_SIZE_IN_H_SHIFT 16 -#define NV01_IMAGE_FROM_CPU_SIZE_IN_H_MASK 0xffff0000 -#define NV01_IMAGE_FROM_CPU_COLOR(x) (0x00000400+((x)*4)) -#define NV01_IMAGE_FROM_CPU_COLOR__SIZE 0x00000020 - - -#define NV04_IMAGE_FROM_CPU 0x00000061 - -#define NV04_IMAGE_FROM_CPU_BETA4 0x00000198 -#define NV04_IMAGE_FROM_CPU_SURFACE 0x0000019c - - -#define NV05_IMAGE_FROM_CPU 0x00000065 - -#define NV05_IMAGE_FROM_CPU_COLOR_CONVERSION 0x000002f8 - - -#define NV10_IMAGE_FROM_CPU 0x0000008a - -#define NV10_IMAGE_FROM_CPU_WAIT_FOR_IDLE 0x00000108 - - -#define NV30_IMAGE_FROM_CPU 0x0000038a - - - -#define NV40_IMAGE_FROM_CPU 0x0000308a - - - -#define NV01_NULL 0x00000030 - - - -#define NV03_STRETCHED_IMAGE_FROM_CPU 0x00000036 - -#define NV03_STRETCHED_IMAGE_FROM_CPU_NOP 0x00000100 -#define NV03_STRETCHED_IMAGE_FROM_CPU_NOTIFY 0x00000104 -#define NV03_STRETCHED_IMAGE_FROM_CPU_PATCH 0x0000010c -#define NV03_STRETCHED_IMAGE_FROM_CPU_DMA_NOTIFY 0x00000180 -#define NV03_STRETCHED_IMAGE_FROM_CPU_COLOR_KEY 0x00000184 -#define NV03_STRETCHED_IMAGE_FROM_CPU_PATTERN 0x00000188 -#define NV03_STRETCHED_IMAGE_FROM_CPU_ROP 0x0000018c -#define NV03_STRETCHED_IMAGE_FROM_CPU_BETA1 0x00000190 -#define NV03_STRETCHED_IMAGE_FROM_CPU_SURFACE 0x00000194 -#define NV03_STRETCHED_IMAGE_FROM_CPU_OPERATION 0x000002fc -#define NV03_STRETCHED_IMAGE_FROM_CPU_COLOR_FORMAT 0x00000300 -#define NV03_STRETCHED_IMAGE_FROM_CPU_SIZE_IN 0x00000304 -#define NV03_STRETCHED_IMAGE_FROM_CPU_SIZE_IN_W_SHIFT 0 -#define NV03_STRETCHED_IMAGE_FROM_CPU_SIZE_IN_W_MASK 0x0000ffff -#define NV03_STRETCHED_IMAGE_FROM_CPU_SIZE_IN_H_SHIFT 16 -#define NV03_STRETCHED_IMAGE_FROM_CPU_SIZE_IN_H_MASK 0xffff0000 -#define NV03_STRETCHED_IMAGE_FROM_CPU_DX_DU 0x00000308 -#define NV03_STRETCHED_IMAGE_FROM_CPU_DY_DV 0x0000030c -#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_POINT 0x00000310 -#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_POINT_X_SHIFT 0 -#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_POINT_X_MASK 0x0000ffff -#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_POINT_Y_SHIFT 16 -#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_POINT_Y_MASK 0xffff0000 -#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_SIZE 0x00000314 -#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_SIZE_W_SHIFT 0 -#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_SIZE_W_MASK 0x0000ffff -#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_SIZE_H_SHIFT 16 -#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_SIZE_H_MASK 0xffff0000 -#define NV03_STRETCHED_IMAGE_FROM_CPU_POINT12D4 0x00000318 -#define NV03_STRETCHED_IMAGE_FROM_CPU_POINT12D4_X_SHIFT 0 -#define NV03_STRETCHED_IMAGE_FROM_CPU_POINT12D4_X_MASK 0x0000ffff -#define NV03_STRETCHED_IMAGE_FROM_CPU_POINT12D4_Y_SHIFT 16 -#define NV03_STRETCHED_IMAGE_FROM_CPU_POINT12D4_Y_MASK 0xffff0000 -#define NV03_STRETCHED_IMAGE_FROM_CPU_COLOR(x) (0x00000400+((x)*4)) -#define NV03_STRETCHED_IMAGE_FROM_CPU_COLOR__SIZE 0x00000020 - - -#define NV04_STRETCHED_IMAGE_FROM_CPU 0x00000076 - -#define NV04_STRETCHED_IMAGE_FROM_CPU_BETA4 0x00000194 -#define NV04_STRETCHED_IMAGE_FROM_CPU_SURFACE 0x00000198 - - -#define NV05_STRETCHED_IMAGE_FROM_CPU 0x00000066 - -#define NV05_STRETCHED_IMAGE_FROM_CPU_COLOR_CONVERSION 0x000002f8 - - -#define NV30_STRETCHED_IMAGE_FROM_CPU 0x00000366 - - - -#define NV40_STRETCHED_IMAGE_FROM_CPU 0x00003066 - - - -#define NV03_SCALED_IMAGE_FROM_MEMORY 0x00000037 - -#define NV03_SCALED_IMAGE_FROM_MEMORY_NOP 0x00000100 -#define NV03_SCALED_IMAGE_FROM_MEMORY_NOTIFY 0x00000104 -#define NV03_SCALED_IMAGE_FROM_MEMORY_DMA_NOTIFY 0x00000180 -#define NV03_SCALED_IMAGE_FROM_MEMORY_DMA_IMAGE 0x00000184 -#define NV03_SCALED_IMAGE_FROM_MEMORY_PATTERN 0x00000188 -#define NV03_SCALED_IMAGE_FROM_MEMORY_ROP 0x0000018c -#define NV03_SCALED_IMAGE_FROM_MEMORY_BETA1 0x00000190 -#define NV03_SCALED_IMAGE_FROM_MEMORY_SURFACE 0x00000194 -#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT 0x00000300 -#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_A1R5G5B5 0x00000001 -#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_X1R5G5B5 0x00000002 -#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_A8R8G8B8 0x00000003 -#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_X8R8G8B8 0x00000004 -#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_V8YB8U8YA8 0x00000005 -#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_YB8V8YA8U8 0x00000006 -#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_R5G6B5 0x00000007 -#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_Y8 0x00000008 -#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_AY8 0x00000009 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION 0x00000304 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_SRCCOPY_AND 0x00000000 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_ROP_AND 0x00000001 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_BLEND_AND 0x00000002 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_SRCCOPY 0x00000003 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_SRCCOPY_PREMULT 0x00000004 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_BLEND_PREMULT 0x00000005 -#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_POINT 0x00000308 -#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_POINT_X_SHIFT 0 -#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_POINT_X_MASK 0x0000ffff -#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_POINT_Y_SHIFT 16 -#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_POINT_Y_MASK 0xffff0000 -#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_SIZE 0x0000030c -#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_SIZE_W_SHIFT 0 -#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_SIZE_W_MASK 0x0000ffff -#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_SIZE_H_SHIFT 16 -#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_SIZE_H_MASK 0xffff0000 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_POINT 0x00000310 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_POINT_X_SHIFT 0 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_POINT_X_MASK 0x0000ffff -#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_POINT_Y_SHIFT 16 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_POINT_Y_MASK 0xffff0000 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_SIZE 0x00000314 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_SIZE_W_SHIFT 0 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_SIZE_W_MASK 0x0000ffff -#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_SIZE_H_SHIFT 16 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_SIZE_H_MASK 0xffff0000 -#define NV03_SCALED_IMAGE_FROM_MEMORY_DU_DX 0x00000318 -#define NV03_SCALED_IMAGE_FROM_MEMORY_DV_DY 0x0000031c -#define NV03_SCALED_IMAGE_FROM_MEMORY_SIZE 0x00000400 -#define NV03_SCALED_IMAGE_FROM_MEMORY_SIZE_W_SHIFT 0 -#define NV03_SCALED_IMAGE_FROM_MEMORY_SIZE_W_MASK 0x0000ffff -#define NV03_SCALED_IMAGE_FROM_MEMORY_SIZE_H_SHIFT 16 -#define NV03_SCALED_IMAGE_FROM_MEMORY_SIZE_H_MASK 0xffff0000 -#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT 0x00000404 -#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_PITCH_SHIFT 0 -#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_PITCH_MASK 0x0000ffff -#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN_SHIFT 16 -#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN_MASK 0x00ff0000 -#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN_CENTER 0x00010000 -#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN_CORNER 0x00020000 -#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER_SHIFT 24 -#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER_MASK 0xff000000 -#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER_POINT_SAMPLE 0x00000000 -#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER_BILINEAR 0x01000000 -#define NV03_SCALED_IMAGE_FROM_MEMORY_OFFSET 0x00000408 -#define NV03_SCALED_IMAGE_FROM_MEMORY_POINT 0x0000040c -#define NV03_SCALED_IMAGE_FROM_MEMORY_POINT_U_SHIFT 0 -#define NV03_SCALED_IMAGE_FROM_MEMORY_POINT_U_MASK 0x0000ffff -#define NV03_SCALED_IMAGE_FROM_MEMORY_POINT_V_SHIFT 16 -#define NV03_SCALED_IMAGE_FROM_MEMORY_POINT_V_MASK 0xffff0000 - - -#define NV04_SCALED_IMAGE_FROM_MEMORY 0x00000077 - -#define NV04_SCALED_IMAGE_FROM_MEMORY_BETA4 0x00000194 -#define NV04_SCALED_IMAGE_FROM_MEMORY_SURFACE 0x00000198 - - -#define NV05_SCALED_IMAGE_FROM_MEMORY 0x00000063 - -#define NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION 0x000002fc -#define NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_DITHER 0x00000000 -#define NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_TRUNCATE 0x00000001 -#define NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_SUBTR_TRUNCATE 0x00000002 - - -#define NV10_SCALED_IMAGE_FROM_MEMORY 0x00000089 - -#define NV10_SCALED_IMAGE_FROM_MEMORY_WAIT_FOR_IDLE 0x00000108 - - -#define NV30_SCALED_IMAGE_FROM_MEMORY 0x00000389 - - - -#define NV40_SCALED_IMAGE_FROM_MEMORY 0x00003089 - - - -#define NV04_DVD_SUBPICTURE 0x00000038 - -#define NV04_DVD_SUBPICTURE_NOP 0x00000100 -#define NV04_DVD_SUBPICTURE_NOTIFY 0x00000104 -#define NV04_DVD_SUBPICTURE_DMA_NOTIFY 0x00000180 -#define NV04_DVD_SUBPICTURE_DMA_OVERLAY 0x00000184 -#define NV04_DVD_SUBPICTURE_DMA_IMAGEIN 0x00000188 -#define NV04_DVD_SUBPICTURE_DMA_IMAGEOUT 0x0000018c -#define NV04_DVD_SUBPICTURE_IMAGEOUT_POINT 0x00000300 -#define NV04_DVD_SUBPICTURE_IMAGEOUT_POINT_X_SHIFT 0 -#define NV04_DVD_SUBPICTURE_IMAGEOUT_POINT_X_MASK 0x0000ffff -#define NV04_DVD_SUBPICTURE_IMAGEOUT_POINT_Y_SHIFT 16 -#define NV04_DVD_SUBPICTURE_IMAGEOUT_POINT_Y_MASK 0xffff0000 -#define NV04_DVD_SUBPICTURE_IMAGEOUT_SIZE 0x00000304 -#define NV04_DVD_SUBPICTURE_IMAGEOUT_SIZE_W_SHIFT 0 -#define NV04_DVD_SUBPICTURE_IMAGEOUT_SIZE_W_MASK 0x0000ffff -#define NV04_DVD_SUBPICTURE_IMAGEOUT_SIZE_H_SHIFT 16 -#define NV04_DVD_SUBPICTURE_IMAGEOUT_SIZE_H_MASK 0xffff0000 -#define NV04_DVD_SUBPICTURE_IMAGEOUT_FORMAT 0x00000308 -#define NV04_DVD_SUBPICTURE_IMAGEOUT_FORMAT_PITCH_SHIFT 0 -#define NV04_DVD_SUBPICTURE_IMAGEOUT_FORMAT_PITCH_MASK 0x0000ffff -#define NV04_DVD_SUBPICTURE_IMAGEOUT_FORMAT_COLOR_SHIFT 16 -#define NV04_DVD_SUBPICTURE_IMAGEOUT_FORMAT_COLOR_MASK 0xffff0000 -#define NV04_DVD_SUBPICTURE_IMAGEOUT_OFFSET 0x0000030c -#define NV04_DVD_SUBPICTURE_IMAGEIN_DELTA_DU_DX 0x00000310 -#define NV04_DVD_SUBPICTURE_IMAGEIN_DELTA_DV_DY 0x00000314 -#define NV04_DVD_SUBPICTURE_IMAGEIN_SIZE 0x00000318 -#define NV04_DVD_SUBPICTURE_IMAGEIN_SIZE_W_SHIFT 0 -#define NV04_DVD_SUBPICTURE_IMAGEIN_SIZE_W_MASK 0x0000ffff -#define NV04_DVD_SUBPICTURE_IMAGEIN_SIZE_H_SHIFT 16 -#define NV04_DVD_SUBPICTURE_IMAGEIN_SIZE_H_MASK 0xffff0000 -#define NV04_DVD_SUBPICTURE_IMAGEIN_FORMAT 0x0000031c -#define NV04_DVD_SUBPICTURE_IMAGEIN_FORMAT_PITCH_SHIFT 0 -#define NV04_DVD_SUBPICTURE_IMAGEIN_FORMAT_PITCH_MASK 0x0000ffff -#define NV04_DVD_SUBPICTURE_IMAGEIN_FORMAT_COLOR_SHIFT 16 -#define NV04_DVD_SUBPICTURE_IMAGEIN_FORMAT_COLOR_MASK 0xffff0000 -#define NV04_DVD_SUBPICTURE_IMAGEIN_OFFSET 0x00000320 -#define NV04_DVD_SUBPICTURE_IMAGEIN_POINT 0x00000324 -#define NV04_DVD_SUBPICTURE_IMAGEIN_POINT_U_SHIFT 0 -#define NV04_DVD_SUBPICTURE_IMAGEIN_POINT_U_MASK 0x0000ffff -#define NV04_DVD_SUBPICTURE_IMAGEIN_POINT_V_SHIFT 16 -#define NV04_DVD_SUBPICTURE_IMAGEIN_POINT_V_MASK 0xffff0000 -#define NV04_DVD_SUBPICTURE_OVERLAY_DELTA_DU_DX 0x00000328 -#define NV04_DVD_SUBPICTURE_OVERLAY_DELTA_DV_DY 0x0000032c -#define NV04_DVD_SUBPICTURE_OVERLAY_SIZE 0x00000330 -#define NV04_DVD_SUBPICTURE_OVERLAY_SIZE_W_SHIFT 0 -#define NV04_DVD_SUBPICTURE_OVERLAY_SIZE_W_MASK 0x0000ffff -#define NV04_DVD_SUBPICTURE_OVERLAY_SIZE_H_SHIFT 16 -#define NV04_DVD_SUBPICTURE_OVERLAY_SIZE_H_MASK 0xffff0000 -#define NV04_DVD_SUBPICTURE_OVERLAY_FORMAT 0x00000334 -#define NV04_DVD_SUBPICTURE_OVERLAY_FORMAT_PITCH_SHIFT 0 -#define NV04_DVD_SUBPICTURE_OVERLAY_FORMAT_PITCH_MASK 0x0000ffff -#define NV04_DVD_SUBPICTURE_OVERLAY_FORMAT_COLOR_SHIFT 16 -#define NV04_DVD_SUBPICTURE_OVERLAY_FORMAT_COLOR_MASK 0xffff0000 -#define NV04_DVD_SUBPICTURE_OVERLAY_OFFSET 0x00000338 -#define NV04_DVD_SUBPICTURE_OVERLAY_POINT 0x0000033c -#define NV04_DVD_SUBPICTURE_OVERLAY_POINT_U_SHIFT 0 -#define NV04_DVD_SUBPICTURE_OVERLAY_POINT_U_MASK 0x0000ffff -#define NV04_DVD_SUBPICTURE_OVERLAY_POINT_V_SHIFT 16 -#define NV04_DVD_SUBPICTURE_OVERLAY_POINT_V_MASK 0xffff0000 - - -#define NV10_DVD_SUBPICTURE 0x00000088 - -#define NV10_DVD_SUBPICTURE_WAIT_FOR_IDLE 0x00000108 - - -#define NV04_MEMORY_TO_MEMORY_FORMAT 0x00000039 - -#define NV04_MEMORY_TO_MEMORY_FORMAT_NOP 0x00000100 -#define NV04_MEMORY_TO_MEMORY_FORMAT_NOTIFY 0x00000104 -#define NV04_MEMORY_TO_MEMORY_FORMAT_DMA_NOTIFY 0x00000180 -#define NV04_MEMORY_TO_MEMORY_FORMAT_DMA_BUFFER_IN 0x00000184 -#define NV04_MEMORY_TO_MEMORY_FORMAT_DMA_BUFFER_OUT 0x00000188 -#define NV04_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN 0x0000030c -#define NV04_MEMORY_TO_MEMORY_FORMAT_OFFSET_OUT 0x00000310 -#define NV04_MEMORY_TO_MEMORY_FORMAT_PITCH_IN 0x00000314 -#define NV04_MEMORY_TO_MEMORY_FORMAT_PITCH_OUT 0x00000318 -#define NV04_MEMORY_TO_MEMORY_FORMAT_LINE_LENGTH_IN 0x0000031c -#define NV04_MEMORY_TO_MEMORY_FORMAT_LINE_COUNT 0x00000320 -#define NV04_MEMORY_TO_MEMORY_FORMAT_FORMAT 0x00000324 -#define NV04_MEMORY_TO_MEMORY_FORMAT_FORMAT_INPUT_INC_SHIFT 0 -#define NV04_MEMORY_TO_MEMORY_FORMAT_FORMAT_INPUT_INC_MASK 0x000000ff -#define NV04_MEMORY_TO_MEMORY_FORMAT_FORMAT_OUTPUT_INC_SHIFT 8 -#define NV04_MEMORY_TO_MEMORY_FORMAT_FORMAT_OUTPUT_INC_MASK 0x0000ff00 -#define NV04_MEMORY_TO_MEMORY_FORMAT_BUF_NOTIFY 0x00000328 - - -#define NV50_MEMORY_TO_MEMORY_FORMAT 0x00005039 - -#define NV50_MEMORY_TO_MEMORY_FORMAT_SERIALIZE 0x00000110 -#define NV50_MEMORY_TO_MEMORY_FORMAT_LINEAR_IN 0x00000200 -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_MODE_IN 0x00000204 -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_PITCH_IN 0x00000208 -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_HEIGHT_IN 0x0000020c -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_DEPTH_IN 0x00000210 -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_IN_Z 0x00000214 -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_IN 0x00000218 -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_IN_X_SHIFT 0 -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_IN_X_MASK 0x0000ffff -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_IN_Y_SHIFT 16 -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_IN_Y_MASK 0xffff0000 -#define NV50_MEMORY_TO_MEMORY_FORMAT_LINEAR_OUT 0x0000021c -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_MODE_OUT 0x00000220 -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_PITCH_OUT 0x00000224 -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_HEIGHT_OUT 0x00000228 -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_DEPTH_OUT 0x0000022c -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_OUT_Z 0x00000230 -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_OUT 0x00000234 -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_OUT_X_SHIFT 0 -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_OUT_X_MASK 0x0000ffff -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_OUT_Y_SHIFT 16 -#define NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_OUT_Y_MASK 0xffff0000 -#define NV50_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN_HIGH 0x00000238 -#define NV50_MEMORY_TO_MEMORY_FORMAT_OFFSET_OUT_HIGH 0x0000023c - - -#define NV01_MEMORY_LOCAL_BANKED 0x0000003d - - - -#define NV01_MAPPING_SYSTEM 0x0000003e - - - -#define NV03_MEMORY_LOCAL_CURSOR 0x0000003f - - - -#define NV01_MEMORY_LOCAL_LINEAR 0x00000040 - - - -#define NV01_MAPPING_LOCAL 0x00000041 - - - -#define NV04_CONTEXT_SURFACES_2D 0x00000042 - -#define NV04_CONTEXT_SURFACES_2D_NOP 0x00000100 -#define NV04_CONTEXT_SURFACES_2D_NOTIFY 0x00000104 -#define NV04_CONTEXT_SURFACES_2D_PM_TRIGGER 0x00000140 -#define NV04_CONTEXT_SURFACES_2D_DMA_NOTIFY 0x00000180 -#define NV04_CONTEXT_SURFACES_2D_DMA_IMAGE_SOURCE 0x00000184 -#define NV04_CONTEXT_SURFACES_2D_DMA_IMAGE_DESTIN 0x00000188 -#define NV04_CONTEXT_SURFACES_2D_FORMAT 0x00000300 -#define NV04_CONTEXT_SURFACES_2D_FORMAT_Y8 0x00000001 -#define NV04_CONTEXT_SURFACES_2D_FORMAT_X1R5G5B5_Z1R5G5B5 0x00000002 -#define NV04_CONTEXT_SURFACES_2D_FORMAT_X1R5G5B5_X1R5G5B5 0x00000003 -#define NV04_CONTEXT_SURFACES_2D_FORMAT_R5G6B5 0x00000004 -#define NV04_CONTEXT_SURFACES_2D_FORMAT_Y16 0x00000005 -#define NV04_CONTEXT_SURFACES_2D_FORMAT_X8R8G8B8_Z8R8G8B8 0x00000006 -#define NV04_CONTEXT_SURFACES_2D_FORMAT_X8R8G8B8_X8R8G8B8 0x00000007 -#define NV04_CONTEXT_SURFACES_2D_FORMAT_X1A7R8G8B8_Z1A7R8G8B8 0x00000008 -#define NV04_CONTEXT_SURFACES_2D_FORMAT_X1A7R8G8B8_X1A7R8G8B8 0x00000009 -#define NV04_CONTEXT_SURFACES_2D_FORMAT_A8R8G8B8 0x0000000a -#define NV04_CONTEXT_SURFACES_2D_FORMAT_Y32 0x0000000b -#define NV04_CONTEXT_SURFACES_2D_PITCH 0x00000304 -#define NV04_CONTEXT_SURFACES_2D_PITCH_SOURCE_SHIFT 0 -#define NV04_CONTEXT_SURFACES_2D_PITCH_SOURCE_MASK 0x0000ffff -#define NV04_CONTEXT_SURFACES_2D_PITCH_DESTIN_SHIFT 16 -#define NV04_CONTEXT_SURFACES_2D_PITCH_DESTIN_MASK 0xffff0000 -#define NV04_CONTEXT_SURFACES_2D_OFFSET_SOURCE 0x00000308 -#define NV04_CONTEXT_SURFACES_2D_OFFSET_DESTIN 0x0000030c - - -#define NV10_CONTEXT_SURFACES_2D 0x00000062 - - - -#define NV30_CONTEXT_SURFACES_2D 0x00000362 - - - -#define NV40_CONTEXT_SURFACES_2D 0x00003062 - - - -#define NV03_CONTEXT_ROP 0x00000043 - -#define NV03_CONTEXT_ROP_NOP 0x00000100 -#define NV03_CONTEXT_ROP_NOTIFY 0x00000104 -#define NV03_CONTEXT_ROP_DMA_NOTIFY 0x00000180 -#define NV03_CONTEXT_ROP_ROP 0x00000300 -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_SHIFT 0 -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_MASK 0x0000000f -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_CLEAR 0x00000000 -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_NOR 0x00000001 -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_AND_INVERTED 0x00000002 -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_COPY_INVERTED 0x00000003 -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_AND_REVERSE 0x00000004 -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_INVERT 0x00000005 -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_XOR 0x00000006 -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_NAND 0x00000007 -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_AND 0x00000008 -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_EQUI 0x00000009 -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_NOOP 0x0000000a -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_OR_INVERTED 0x0000000b -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_COPY 0x0000000c -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_OR_REVERSE 0x0000000d -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_OR 0x0000000e -#define NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_SET 0x0000000f -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_SHIFT 4 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_MASK 0x000000f0 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_CLEAR 0x00000000 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_NOR 0x00000010 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_AND_INVERTED 0x00000020 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_COPY_INVERTED 0x00000030 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_AND_REVERSE 0x00000040 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_INVERT 0x00000050 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_XOR 0x00000060 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_NAND 0x00000070 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_AND 0x00000080 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_EQUI 0x00000090 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_NOOP 0x000000a0 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_OR_INVERTED 0x000000b0 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_COPY 0x000000c0 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_OR_REVERSE 0x000000d0 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_OR 0x000000e0 -#define NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_SET 0x000000f0 - - -#define NV04_IMAGE_PATTERN 0x00000044 - -#define NV04_IMAGE_PATTERN_NOP 0x00000100 -#define NV04_IMAGE_PATTERN_NOTIFY 0x00000104 -#define NV04_IMAGE_PATTERN_DMA_NOTIFY 0x00000180 -#define NV04_IMAGE_PATTERN_COLOR_FORMAT 0x00000300 -#define NV04_IMAGE_PATTERN_COLOR_FORMAT_A16R5G6B5 0x00000001 -#define NV04_IMAGE_PATTERN_COLOR_FORMAT_X16A1R5G5B5 0x00000002 -#define NV04_IMAGE_PATTERN_COLOR_FORMAT_A8R8G8B8 0x00000003 -#define NV04_IMAGE_PATTERN_MONOCHROME_FORMAT 0x00000304 -#define NV04_IMAGE_PATTERN_MONOCHROME_FORMAT_CGA6 0x00000001 -#define NV04_IMAGE_PATTERN_MONOCHROME_FORMAT_LE 0x00000002 -#define NV04_IMAGE_PATTERN_MONOCHROME_SHAPE 0x00000308 -#define NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_8X8 0x00000000 -#define NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_64X1 0x00000001 -#define NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_1X64 0x00000002 -#define NV04_IMAGE_PATTERN_PATTERN_SELECT 0x0000030c -#define NV04_IMAGE_PATTERN_PATTERN_SELECT_MONO 0x00000001 -#define NV04_IMAGE_PATTERN_PATTERN_SELECT_COLOR 0x00000002 -#define NV04_IMAGE_PATTERN_MONOCHROME_COLOR0 0x00000310 -#define NV04_IMAGE_PATTERN_MONOCHROME_COLOR1 0x00000314 -#define NV04_IMAGE_PATTERN_MONOCHROME_PATTERN0 0x00000318 -#define NV04_IMAGE_PATTERN_MONOCHROME_PATTERN1 0x0000031c -#define NV04_IMAGE_PATTERN_PATTERN_Y8(x) (0x00000400+((x)*4)) -#define NV04_IMAGE_PATTERN_PATTERN_Y8__SIZE 0x00000010 -#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y0_SHIFT 0 -#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y0_MASK 0x000000ff -#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y1_SHIFT 8 -#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y1_MASK 0x0000ff00 -#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y2_SHIFT 16 -#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y2_MASK 0x00ff0000 -#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y3_SHIFT 24 -#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y3_MASK 0xff000000 -#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5(x) (0x00000500+((x)*4)) -#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5__SIZE 0x00000020 -#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_B0_SHIFT 0 -#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_B0_MASK 0x0000001f -#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_G0_SHIFT 5 -#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_G0_MASK 0x000007e0 -#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_R0_SHIFT 11 -#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_R0_MASK 0x0000f800 -#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_B1_SHIFT 16 -#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_B1_MASK 0x001f0000 -#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_G1_SHIFT 21 -#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_G1_MASK 0x07e00000 -#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_R1_SHIFT 27 -#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_R1_MASK 0xf8000000 -#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5(x) (0x00000600+((x)*4)) -#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5__SIZE 0x00000020 -#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_B0_SHIFT 0 -#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_B0_MASK 0x0000001f -#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_G0_SHIFT 5 -#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_G0_MASK 0x000003e0 -#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_R0_SHIFT 10 -#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_R0_MASK 0x00007c00 -#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_B1_SHIFT 16 -#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_B1_MASK 0x001f0000 -#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_G1_SHIFT 21 -#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_G1_MASK 0x03e00000 -#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_R1_SHIFT 26 -#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_R1_MASK 0x7c000000 -#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8(x) (0x00000700+((x)*4)) -#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8__SIZE 0x00000040 -#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_B_SHIFT 0 -#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_B_MASK 0x000000ff -#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_G_SHIFT 8 -#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_G_MASK 0x0000ff00 -#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_R_SHIFT 16 -#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_R_MASK 0x00ff0000 - - -#define NV03_VIDEO_LUT_CURSOR_DAC 0x00000046 - -#define NV03_VIDEO_LUT_CURSOR_DAC_SYNCHRONIZE 0x00000100 -#define NV03_VIDEO_LUT_CURSOR_DAC_STOP_IMAGE 0x00000104 -#define NV03_VIDEO_LUT_CURSOR_DAC_STOP_CURSOR 0x00000108 -#define NV03_VIDEO_LUT_CURSOR_DAC_STOP_DAC 0x0000010c -#define NV03_VIDEO_LUT_CURSOR_DAC_DMA_NOTIFY 0x00000180 -#define NV03_VIDEO_LUT_CURSOR_DAC_DMA_IMAGE(x) (0x00000184+((x)*4)) -#define NV03_VIDEO_LUT_CURSOR_DAC_DMA_IMAGE__SIZE 0x00000002 -#define NV03_VIDEO_LUT_CURSOR_DAC_DMA_LUT(x) (0x0000018c+((x)*4)) -#define NV03_VIDEO_LUT_CURSOR_DAC_DMA_LUT__SIZE 0x00000002 -#define NV03_VIDEO_LUT_CURSOR_DAC_DMA_CURSOR(x) (0x00000194+((x)*4)) -#define NV03_VIDEO_LUT_CURSOR_DAC_DMA_CURSOR__SIZE 0x00000002 -#define NV03_VIDEO_LUT_CURSOR_DAC_GET 0x000002fc -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_OFFSET(x) (0x00000300+((x)*8)) -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_OFFSET__SIZE 0x00000002 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT(x) (0x00000304+((x)*8)) -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT__SIZE 0x00000002 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT_PITCH_SHIFT 0 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT_PITCH_MASK 0x0000ffff -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT_COLOR_SHIFT 16 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT_COLOR_MASK 0x0fff0000 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT_NOTIFY_SHIFT 28 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT_NOTIFY_MASK 0xf0000000 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_OFFSET(x) (0x00000340+((x)*12)) -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_OFFSET__SIZE 0x00000002 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT(x) (0x00000344+((x)*12)) -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT__SIZE 0x00000002 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_X_SHIFT 0 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_X_MASK 0x0000ffff -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_Y_SHIFT 16 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_Y_MASK 0xffff0000 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_FORMAT(x) (0x00000348+((x)*12)) -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_FORMAT__SIZE 0x00000002 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_A 0x00000358 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_A_X_SHIFT 0 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_A_X_MASK 0x0000ffff -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_A_Y_SHIFT 16 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_A_Y_MASK 0xffff0000 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_IMAGE_SIZE(x) (0x00000380+((x)*16)) -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_IMAGE_SIZE__SIZE 0x00000002 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_IMAGE_SIZE_W_SHIFT 0 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_IMAGE_SIZE_W_MASK 0x0000ffff -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_IMAGE_SIZE_H_SHIFT 16 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_IMAGE_SIZE_H_MASK 0xffff0000 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC(x) (0x00000384+((x)*16)) -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC__SIZE 0x00000002 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC_START_SHIFT 0 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC_START_MASK 0x0000ffff -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC_WIDTH_SHIFT 16 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC_WIDTH_MASK 0x0fff0000 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC_POLARITY_SHIFT 28 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC_POLARITY_MASK 0xf0000000 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC(x) (0x00000388+((x)*16)) -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC__SIZE 0x00000002 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC_START_SHIFT 0 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC_START_MASK 0x0000ffff -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC_WIDTH_SHIFT 16 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC_WIDTH_MASK 0x0fff0000 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC_POLARITY_SHIFT 28 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC_POLARITY_MASK 0xf0000000 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE(x) (0x0000038c+((x)*16)) -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE__SIZE 0x00000002 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE_WIDTH_SHIFT 0 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE_WIDTH_MASK 0x0000ffff -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE_HEIGHT_SHIFT 16 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE_HEIGHT_MASK 0x0fff0000 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE_NOTIFY_SHIFT 28 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE_NOTIFY_MASK 0xf0000000 -#define NV03_VIDEO_LUT_CURSOR_DAC_SET_PIXEL_CLOCK 0x000003a0 - - -#define NV03_TEXTURED_TRIANGLE 0x00000048 - -#define NV03_TEXTURED_TRIANGLE_NOP 0x00000100 -#define NV03_TEXTURED_TRIANGLE_NOTIFY 0x00000104 -#define NV03_TEXTURED_TRIANGLE_PATCH 0x0000010c -#define NV03_TEXTURED_TRIANGLE_DMA_NOTIFY 0x00000180 -#define NV03_TEXTURED_TRIANGLE_DMA_TEXTURE 0x00000184 -#define NV03_TEXTURED_TRIANGLE_CLIP_RECTANGLE 0x00000188 -#define NV03_TEXTURED_TRIANGLE_SURFACE 0x0000018c -#define NV03_TEXTURED_TRIANGLE_TEXTURE_OFFSET 0x00000304 -#define NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT 0x00000308 -#define NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_COLOR_KEY_MASK_SHIFT 0 -#define NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_COLOR_KEY_MASK_MASK 0x0000ffff -#define NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_COLOR_KEY_ENABLE_SHIFT 16 -#define NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_COLOR_KEY_ENABLE_MASK 0x000f0000 -#define NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_COLOR_SHIFT 20 -#define NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_COLOR_MASK 0x00f00000 -#define NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_SIZE_MIN_SHIFT 24 -#define NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_SIZE_MIN_MASK 0x0f000000 -#define NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_SIZE_MAX_SHIFT 28 -#define NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_SIZE_MAX_MASK 0xf0000000 -#define NV03_TEXTURED_TRIANGLE_FILTER 0x0000030c -#define NV03_TEXTURED_TRIANGLE_FILTER_SPREAD_X_SHIFT 0 -#define NV03_TEXTURED_TRIANGLE_FILTER_SPREAD_X_MASK 0x0000001f -#define NV03_TEXTURED_TRIANGLE_FILTER_SPREAD_Y_SHIFT 8 -#define NV03_TEXTURED_TRIANGLE_FILTER_SPREAD_Y_MASK 0x00001f00 -#define NV03_TEXTURED_TRIANGLE_FILTER_SIZE_ADJUST_SHIFT 16 -#define NV03_TEXTURED_TRIANGLE_FILTER_SIZE_ADJUST_MASK 0x00ff0000 -#define NV03_TEXTURED_TRIANGLE_FOG_COLOR 0x00000310 -#define NV03_TEXTURED_TRIANGLE_FOG_COLOR_B_SHIFT 0 -#define NV03_TEXTURED_TRIANGLE_FOG_COLOR_B_MASK 0x000000ff -#define NV03_TEXTURED_TRIANGLE_FOG_COLOR_G_SHIFT 8 -#define NV03_TEXTURED_TRIANGLE_FOG_COLOR_G_MASK 0x0000ff00 -#define NV03_TEXTURED_TRIANGLE_FOG_COLOR_R_SHIFT 16 -#define NV03_TEXTURED_TRIANGLE_FOG_COLOR_R_MASK 0x00ff0000 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT 0x00000314 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_INTERPOLATOR_SHIFT 0 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_INTERPOLATOR_MASK 0x0000000f -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_WRAP_U_SHIFT 4 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_WRAP_U_MASK 0x00000030 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_WRAP_V_SHIFT 6 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_WRAP_V_MASK 0x000000c0 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_SOURCE_COLOR_SHIFT 8 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_SOURCE_COLOR_MASK 0x00000f00 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_CULLING_SHIFT 12 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_CULLING_MASK 0x00007000 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_Z_PERSPECTIVE_ENABLE (1 << 15) -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_Z_FUNC_SHIFT 16 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_Z_FUNC_MASK 0x000f0000 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_Z_WRITE_ENABLE_SHIFT 20 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_Z_WRITE_ENABLE_MASK 0x00f00000 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_COLOR_WRITE_ENABLE_SHIFT 24 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_COLOR_WRITE_ENABLE_MASK 0x07000000 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_ROP_SHIFT 27 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_ROP_MASK 0x18000000 -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_BETA (1 << 29) -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_DST_BLEND (1 << 30) -#define NV03_TEXTURED_TRIANGLE_CONTROL_OUT_SRC_BLEND (1 << 31) -#define NV03_TEXTURED_TRIANGLE_ALPHA_CONTROL 0x00000318 -#define NV03_TEXTURED_TRIANGLE_ALPHA_CONTROL_ALPHA_REF_SHIFT 0 -#define NV03_TEXTURED_TRIANGLE_ALPHA_CONTROL_ALPHA_REF_MASK 0x000000ff -#define NV03_TEXTURED_TRIANGLE_ALPHA_CONTROL_ALPHA_FUNC_SHIFT 8 -#define NV03_TEXTURED_TRIANGLE_ALPHA_CONTROL_ALPHA_FUNC_MASK 0xffffff00 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR(x) (0x00001000+((x)*32)) -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR__SIZE 0x00000080 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I0_SHIFT 0 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I0_MASK 0x0000000f -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I1_SHIFT 4 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I1_MASK 0x000000f0 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I2_SHIFT 8 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I2_MASK 0x00000f00 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I3_SHIFT 12 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I3_MASK 0x0000f000 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I4_SHIFT 16 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I4_MASK 0x000f0000 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I5_SHIFT 20 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I5_MASK 0x00f00000 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_FOG_SHIFT 24 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_FOG_MASK 0xff000000 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_COLOR(x) (0x00001004+((x)*32)) -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_COLOR__SIZE 0x00000080 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SX(x) (0x00001008+((x)*32)) -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SX__SIZE 0x00000080 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SY(x) (0x0000100c+((x)*32)) -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SY__SIZE 0x00000080 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SZ(x) (0x00001010+((x)*32)) -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_SZ__SIZE 0x00000080 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_RHW(x) (0x00001014+((x)*32)) -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_RHW__SIZE 0x00000080 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_TU(x) (0x00001018+((x)*32)) -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_TU__SIZE 0x00000080 -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_TV(x) (0x0000101c+((x)*32)) -#define NV03_TEXTURED_TRIANGLE_TLVERTEX_TV__SIZE 0x00000080 - - -#define NV04_GDI_RECTANGLE_TEXT 0x0000004a - -#define NV04_GDI_RECTANGLE_TEXT_NOP 0x00000100 -#define NV04_GDI_RECTANGLE_TEXT_NOTIFY 0x00000104 -#define NV04_GDI_RECTANGLE_TEXT_PATCH 0x0000010c -#define NV04_GDI_RECTANGLE_TEXT_PM_TRIGGER 0x00000140 -#define NV04_GDI_RECTANGLE_TEXT_DMA_NOTIFY 0x00000180 -#define NV04_GDI_RECTANGLE_TEXT_DMA_FONTS 0x00000184 -#define NV04_GDI_RECTANGLE_TEXT_PATTERN 0x00000188 -#define NV04_GDI_RECTANGLE_TEXT_ROP 0x0000018c -#define NV04_GDI_RECTANGLE_TEXT_BETA1 0x00000190 -#define NV04_GDI_RECTANGLE_TEXT_BETA4 0x00000194 -#define NV04_GDI_RECTANGLE_TEXT_SURFACE 0x00000198 -#define NV04_GDI_RECTANGLE_TEXT_OPERATION 0x000002fc -#define NV04_GDI_RECTANGLE_TEXT_OPERATION_SRCCOPY_AND 0x00000000 -#define NV04_GDI_RECTANGLE_TEXT_OPERATION_ROP_AND 0x00000001 -#define NV04_GDI_RECTANGLE_TEXT_OPERATION_BLEND_AND 0x00000002 -#define NV04_GDI_RECTANGLE_TEXT_OPERATION_SRCCOPY 0x00000003 -#define NV04_GDI_RECTANGLE_TEXT_OPERATION_SRCCOPY_PREMULT 0x00000004 -#define NV04_GDI_RECTANGLE_TEXT_OPERATION_BLEND_PREMULT 0x00000005 -#define NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT 0x00000300 -#define NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A16R5G6B5 0x00000001 -#define NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_X16A1R5G5B5 0x00000002 -#define NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A8R8G8B8 0x00000003 -#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT 0x00000304 -#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT_CGA6 0x00000001 -#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT_LE 0x00000002 -#define NV04_GDI_RECTANGLE_TEXT_COLOR1_A 0x000003fc -#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT(x) (0x00000400+((x)*8)) -#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT__SIZE 0x00000020 -#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_Y_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_Y_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_X_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_X_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE(x) (0x00000404+((x)*8)) -#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE__SIZE 0x00000020 -#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_H_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_H_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_W_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_W_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT0 0x000005f4 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT0_L_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT0_L_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT0_T_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT0_T_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT1 0x000005f8 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT1_R_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT1_R_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT1_B_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT1_B_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_COLOR1_B 0x000005fc -#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0(x) (0x00000600+((x)*8)) -#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0__SIZE 0x00000020 -#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_L_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_L_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_T_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_T_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1(x) (0x00000604+((x)*8)) -#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1__SIZE 0x00000020 -#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_R_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_R_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_B_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_B_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT0 0x000007ec -#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_L_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_L_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_T_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_T_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT1 0x000007f0 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_R_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_R_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_B_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_B_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_COLOR1_C 0x000007f4 -#define NV04_GDI_RECTANGLE_TEXT_SIZE_C 0x000007f8 -#define NV04_GDI_RECTANGLE_TEXT_SIZE_C_W_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_SIZE_C_W_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_SIZE_C_H_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_SIZE_C_H_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_POINT_C 0x000007fc -#define NV04_GDI_RECTANGLE_TEXT_POINT_C_X_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_POINT_C_X_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_POINT_C_Y_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_POINT_C_Y_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_C(x) (0x00000800+((x)*4)) -#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_C__SIZE 0x00000080 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT0 0x00000be4 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_L_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_L_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_T_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_T_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT1 0x00000be8 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_R_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_R_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_B_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_B_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_COLOR0_E 0x00000bec -#define NV04_GDI_RECTANGLE_TEXT_COLOR1_E 0x00000bf0 -#define NV04_GDI_RECTANGLE_TEXT_SIZE_IN_E 0x00000bf4 -#define NV04_GDI_RECTANGLE_TEXT_SIZE_IN_E_W_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_SIZE_IN_E_W_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_SIZE_IN_E_H_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_SIZE_IN_E_H_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_SIZE_OUT_E 0x00000bf8 -#define NV04_GDI_RECTANGLE_TEXT_SIZE_OUT_E_W_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_SIZE_OUT_E_W_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_SIZE_OUT_E_H_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_SIZE_OUT_E_H_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_POINT_E 0x00000bfc -#define NV04_GDI_RECTANGLE_TEXT_POINT_E_X_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_POINT_E_X_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_POINT_E_Y_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_POINT_E_Y_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR01_E(x) (0x00000c00+((x)*4)) -#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR01_E__SIZE 0x00000080 -#define NV04_GDI_RECTANGLE_TEXT_FONT_F 0x00000ff0 -#define NV04_GDI_RECTANGLE_TEXT_FONT_F_OFFSET_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_FONT_F_OFFSET_MASK 0x0fffffff -#define NV04_GDI_RECTANGLE_TEXT_FONT_F_PITCH_SHIFT 28 -#define NV04_GDI_RECTANGLE_TEXT_FONT_F_PITCH_MASK 0xf0000000 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT0 0x00000ff4 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT0_L_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT0_L_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT0_T_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT0_T_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT1 0x00000ff8 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT1_R_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT1_R_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT1_B_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT1_B_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_COLOR1_F 0x00000ffc -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F(x) (0x00001000+((x)*4)) -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F__SIZE 0x00000100 -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_INDEX_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_INDEX_MASK 0x000000ff -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_X_SHIFT 8 -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_X_MASK 0x000fff00 -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_Y_SHIFT 20 -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_Y_MASK 0xfff00000 -#define NV04_GDI_RECTANGLE_TEXT_FONT_G 0x000017f0 -#define NV04_GDI_RECTANGLE_TEXT_FONT_G_OFFSET_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_FONT_G_OFFSET_MASK 0x0fffffff -#define NV04_GDI_RECTANGLE_TEXT_FONT_G_PITCH_SHIFT 28 -#define NV04_GDI_RECTANGLE_TEXT_FONT_G_PITCH_MASK 0xf0000000 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT0 0x000017f4 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT0_L_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT0_L_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT0_T_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT0_T_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT1 0x000017f8 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT1_R_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT1_R_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT1_B_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT1_B_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_COLOR1_G 0x000017fc -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT(x) (0x00001800+((x)*8)) -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT__SIZE 0x00000100 -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT_X_SHIFT 0 -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT_X_MASK 0x0000ffff -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT_Y_SHIFT 16 -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT_Y_MASK 0xffff0000 -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_INDEX(x) (0x00001804+((x)*8)) -#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_INDEX__SIZE 0x00000100 - - -#define NV03_GDI_RECTANGLE_TEXT 0x0000004b - -#define NV03_GDI_RECTANGLE_TEXT_NOP 0x00000100 -#define NV03_GDI_RECTANGLE_TEXT_NOTIFY 0x00000104 -#define NV03_GDI_RECTANGLE_TEXT_DMA_NOTIFY 0x00000180 -#define NV03_GDI_RECTANGLE_TEXT_PATTERN 0x00000184 -#define NV03_GDI_RECTANGLE_TEXT_ROP 0x00000188 -#define NV03_GDI_RECTANGLE_TEXT_BETA1 0x0000018c -#define NV03_GDI_RECTANGLE_TEXT_SURFACE 0x00000190 -#define NV03_GDI_RECTANGLE_TEXT_OPERATION 0x000002fc -#define NV03_GDI_RECTANGLE_TEXT_COLOR_FORMAT 0x00000300 -#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT 0x00000304 -#define NV03_GDI_RECTANGLE_TEXT_COLOR1_A 0x000003fc -#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT 0x00000400 -#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_Y_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_Y_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_X_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_X_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE 0x00000404 -#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_H_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_H_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_W_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_W_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT0_B 0x000007f4 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT0_B_L_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT0_B_L_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT0_B_T_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT0_B_T_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT1_B 0x000007f8 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT1_B_R_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT1_B_R_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT1_B_B_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT1_B_B_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_COLOR1_B 0x000007fc -#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0 0x00000800 -#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_L_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_L_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_T_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_T_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1 0x00000804 -#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_R_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_R_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_B_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_B_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT0 0x00000bec -#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_L_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_L_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_T_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_T_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT1 0x00000bf0 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_R_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_R_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_B_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_B_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_COLOR1_C 0x00000bf4 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_C 0x00000bf8 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_C_W_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_C_W_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_SIZE_C_H_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_C_H_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_POINT_C 0x00000bfc -#define NV03_GDI_RECTANGLE_TEXT_POINT_C_X_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_POINT_C_X_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_POINT_C_Y_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_POINT_C_Y_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_C(x) (0x00000c00+((x)*4)) -#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_C__SIZE 0x00000020 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT0 0x00000fe8 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT0_L_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT0_L_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT0_T_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT0_T_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT1 0x00000fec -#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT1_R_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT1_R_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT1_B_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT1_B_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_COLOR1_D 0x00000ff0 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_D 0x00000ff4 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_D_W_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_D_W_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_D_H_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_D_H_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_D 0x00000ff8 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_D_W_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_D_W_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_D_H_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_D_H_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_POINT_D 0x00000ffc -#define NV03_GDI_RECTANGLE_TEXT_POINT_D_X_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_POINT_D_X_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_POINT_D_Y_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_POINT_D_Y_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_D(x) (0x00001000+((x)*4)) -#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_D__SIZE 0x00000020 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT0 0x000013e4 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_L_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_L_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_T_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_T_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT1 0x000013e8 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_R_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_R_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_B_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_B_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_COLOR0_E 0x000013ec -#define NV03_GDI_RECTANGLE_TEXT_COLOR1_E 0x000013f0 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_E 0x000013f4 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_E_W_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_E_W_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_E_H_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_E_H_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_E 0x000013f8 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_E_W_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_E_W_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_E_H_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_E_H_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_POINT_E 0x000013fc -#define NV03_GDI_RECTANGLE_TEXT_POINT_E_X_SHIFT 0 -#define NV03_GDI_RECTANGLE_TEXT_POINT_E_X_MASK 0x0000ffff -#define NV03_GDI_RECTANGLE_TEXT_POINT_E_Y_SHIFT 16 -#define NV03_GDI_RECTANGLE_TEXT_POINT_E_Y_MASK 0xffff0000 -#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR01_E(x) (0x00001400+((x)*4)) -#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR01_E__SIZE 0x00000020 - - -#define NV04_SWIZZLED_SURFACE 0x00000052 - -#define NV04_SWIZZLED_SURFACE_NOP 0x00000100 -#define NV04_SWIZZLED_SURFACE_NOTIFY 0x00000104 -#define NV04_SWIZZLED_SURFACE_DMA_NOTIFY 0x00000180 -#define NV04_SWIZZLED_SURFACE_DMA_IMAGE 0x00000184 -#define NV04_SWIZZLED_SURFACE_FORMAT 0x00000300 -#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_SHIFT 0 -#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_MASK 0x000000ff -#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_Y8 0x00000001 -#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X1R5G5B5_Z1R5G5B5 0x00000002 -#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X1R5G5B5_X1R5G5B5 0x00000003 -#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_R5G6B5 0x00000004 -#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_Y16 0x00000005 -#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X8R8G8B8_Z8R8G8B8 0x00000006 -#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X8R8G8B8_X8R8G8B8 0x00000007 -#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X1A7R8G8B8_Z1A7R8G8B8 0x00000008 -#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X1A7R8G8B8_X1A7R8G8B8 0x00000009 -#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_A8R8G8B8 0x0000000a -#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_Y32 0x0000000b -#define NV04_SWIZZLED_SURFACE_FORMAT_BASE_SIZE_U_SHIFT 16 -#define NV04_SWIZZLED_SURFACE_FORMAT_BASE_SIZE_U_MASK 0x00ff0000 -#define NV04_SWIZZLED_SURFACE_FORMAT_BASE_SIZE_V_SHIFT 24 -#define NV04_SWIZZLED_SURFACE_FORMAT_BASE_SIZE_V_MASK 0xff000000 -#define NV04_SWIZZLED_SURFACE_OFFSET 0x00000304 - - -#define NV20_SWIZZLED_SURFACE 0x0000009e - - - -#define NV30_SWIZZLED_SURFACE 0x0000039e - - - -#define NV40_SWIZZLED_SURFACE 0x0000309e - - - -#define NV04_CONTEXT_SURFACES_3D 0x00000053 - -#define NV04_CONTEXT_SURFACES_3D_NOP 0x00000100 -#define NV04_CONTEXT_SURFACES_3D_NOTIFY 0x00000104 -#define NV04_CONTEXT_SURFACES_3D_DMA_NOTIFY 0x00000180 -#define NV04_CONTEXT_SURFACES_3D_DMA_COLOR 0x00000184 -#define NV04_CONTEXT_SURFACES_3D_DMA_ZETA 0x00000188 -#define NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL 0x000002f8 -#define NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL_X_SHIFT 0 -#define NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL_X_MASK 0x0000ffff -#define NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL_W_SHIFT 16 -#define NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL_W_MASK 0xffff0000 -#define NV04_CONTEXT_SURFACES_3D_CLIP_VERTICAL 0x000002fc -#define NV04_CONTEXT_SURFACES_3D_CLIP_VERTICAL_Y_SHIFT 0 -#define NV04_CONTEXT_SURFACES_3D_CLIP_VERTICAL_Y_MASK 0x0000ffff -#define NV04_CONTEXT_SURFACES_3D_CLIP_VERTICAL_H_SHIFT 16 -#define NV04_CONTEXT_SURFACES_3D_CLIP_VERTICAL_H_MASK 0xffff0000 -#define NV04_CONTEXT_SURFACES_3D_FORMAT 0x00000300 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_SHIFT 0 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_MASK 0x000000ff -#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X1R5G5B5_Z1R5G5B5 0x00000001 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X1R5G5B5_X1R5G5B5 0x00000002 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_R5G6B5 0x00000003 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X8R8G8B8_Z8R8G8B8 0x00000004 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X8R8G8B8_X8R8G8B8 0x00000005 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X1A7R8G8B8_Z1A7R8G8B8 0x00000006 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X1A7R8G8B8_X1A7R8G8B8 0x00000007 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_A8R8G8B8 0x00000008 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_TYPE_SHIFT 8 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_TYPE_MASK 0x0000ff00 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_TYPE_PITCH 0x00000100 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_TYPE_SWIZZLE 0x00000200 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_BASE_SIZE_U_SHIFT 16 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_BASE_SIZE_U_MASK 0x00ff0000 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_BASE_SIZE_V_SHIFT 24 -#define NV04_CONTEXT_SURFACES_3D_FORMAT_BASE_SIZE_V_MASK 0xff000000 -#define NV04_CONTEXT_SURFACES_3D_CLIP_SIZE 0x00000304 -#define NV04_CONTEXT_SURFACES_3D_CLIP_SIZE_W_SHIFT 0 -#define NV04_CONTEXT_SURFACES_3D_CLIP_SIZE_W_MASK 0x0000ffff -#define NV04_CONTEXT_SURFACES_3D_CLIP_SIZE_H_SHIFT 16 -#define NV04_CONTEXT_SURFACES_3D_CLIP_SIZE_H_MASK 0xffff0000 -#define NV04_CONTEXT_SURFACES_3D_PITCH 0x00000308 -#define NV04_CONTEXT_SURFACES_3D_PITCH_COLOR_SHIFT 0 -#define NV04_CONTEXT_SURFACES_3D_PITCH_COLOR_MASK 0x0000ffff -#define NV04_CONTEXT_SURFACES_3D_PITCH_ZETA_SHIFT 16 -#define NV04_CONTEXT_SURFACES_3D_PITCH_ZETA_MASK 0xffff0000 -#define NV04_CONTEXT_SURFACES_3D_OFFSET_COLOR 0x0000030c -#define NV04_CONTEXT_SURFACES_3D_OFFSET_ZETA 0x00000310 - - -#define NV10_CONTEXT_SURFACES_3D 0x00000093 - - - -#define NV04_TEXTURED_TRIANGLE 0x00000054 - -#define NV04_TEXTURED_TRIANGLE_NOP 0x00000100 -#define NV04_TEXTURED_TRIANGLE_NOTIFY 0x00000104 -#define NV04_TEXTURED_TRIANGLE_DMA_NOTIFY 0x00000180 -#define NV04_TEXTURED_TRIANGLE_DMA_A 0x00000184 -#define NV04_TEXTURED_TRIANGLE_DMA_B 0x00000188 -#define NV04_TEXTURED_TRIANGLE_SURFACE 0x0000018c -#define NV04_TEXTURED_TRIANGLE_COLORKEY 0x00000300 -#define NV04_TEXTURED_TRIANGLE_OFFSET 0x00000304 -#define NV04_TEXTURED_TRIANGLE_FORMAT 0x00000308 -#define NV04_TEXTURED_TRIANGLE_FORMAT_DMA_A (1 << 0) -#define NV04_TEXTURED_TRIANGLE_FORMAT_DMA_B (1 << 1) -#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_KEY_MATCH_SHIFT 2 -#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_KEY_MATCH_MASK 0x0000000c -#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_ZOH_SHIFT 4 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_ZOH_MASK 0x00000030 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_ZOH_CENTER 0x00000010 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_ZOH_CORNER 0x00000020 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_FOH_SHIFT 6 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_FOH_MASK 0x000000c0 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_FOH_CENTER 0x00000040 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_FOH_CORNER 0x00000080 -#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_SHIFT 8 -#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_MASK 0x00000f00 -#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_Y8 0x00000100 -#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_A1R5G5B5 0x00000200 -#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_X1R5G5B5 0x00000300 -#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_A4R4G4B4 0x00000400 -#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_R5G6B5 0x00000500 -#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_A8R8G8B8 0x00000600 -#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_X8R8G8B8 0x00000700 -#define NV04_TEXTURED_TRIANGLE_FORMAT_MIPMAP_LEVELS_SHIFT 12 -#define NV04_TEXTURED_TRIANGLE_FORMAT_MIPMAP_LEVELS_MASK 0x0000f000 -#define NV04_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_U_SHIFT 16 -#define NV04_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_U_MASK 0x000f0000 -#define NV04_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_V_SHIFT 20 -#define NV04_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_V_MASK 0x00f00000 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_SHIFT 24 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_MASK 0x07000000 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_REPEAT 0x01000000 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_MIRRORED_REPEAT 0x02000000 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_CLAMP_TO_EDGE 0x03000000 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_CLAMP_TO_BORDER 0x04000000 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_CLAMP 0x05000000 -#define NV04_TEXTURED_TRIANGLE_FORMAT_WRAPU (1 << 27) -#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_SHIFT 28 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_MASK 0x70000000 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_REPEAT 0x10000000 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_MIRRORED_REPEAT 0x20000000 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_CLAMP_TO_EDGE 0x30000000 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_CLAMP_TO_BORDER 0x40000000 -#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_CLAMP 0x50000000 -#define NV04_TEXTURED_TRIANGLE_FORMAT_WRAPV (1 << 31) -#define NV04_TEXTURED_TRIANGLE_FILTER 0x0000030c -#define NV04_TEXTURED_TRIANGLE_FILTER_KERNEL_SIZE_X_SHIFT 0 -#define NV04_TEXTURED_TRIANGLE_FILTER_KERNEL_SIZE_X_MASK 0x000000ff -#define NV04_TEXTURED_TRIANGLE_FILTER_KERNEL_SIZE_Y_SHIFT 8 -#define NV04_TEXTURED_TRIANGLE_FILTER_KERNEL_SIZE_Y_MASK 0x00007f00 -#define NV04_TEXTURED_TRIANGLE_FILTER_MIPMAP_DITHER_ENABLE (1 << 15) -#define NV04_TEXTURED_TRIANGLE_FILTER_MIPMAP_LODBIAS_SHIFT 16 -#define NV04_TEXTURED_TRIANGLE_FILTER_MIPMAP_LODBIAS_MASK 0x00ff0000 -#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_SHIFT 24 -#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_MASK 0x07000000 -#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_NEAREST 0x01000000 -#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_LINEAR 0x02000000 -#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_NEAREST_MIPMAP_NEAREST 0x03000000 -#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_LINEAR_MIPMAP_NEAREST 0x04000000 -#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_NEAREST_MIPMAP_LINEAR 0x05000000 -#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_LINEAR_MIPMAP_LINEAR 0x06000000 -#define NV04_TEXTURED_TRIANGLE_FILTER_ANISOTROPIC_MINIFY_ENABLE (1 << 27) -#define NV04_TEXTURED_TRIANGLE_FILTER_MAGNIFY_SHIFT 28 -#define NV04_TEXTURED_TRIANGLE_FILTER_MAGNIFY_MASK 0x70000000 -#define NV04_TEXTURED_TRIANGLE_FILTER_MAGNIFY_NEAREST 0x10000000 -#define NV04_TEXTURED_TRIANGLE_FILTER_MAGNIFY_LINEAR 0x20000000 -#define NV04_TEXTURED_TRIANGLE_FILTER_ANISOTROPIC_MAGNIFY_ENABLE (1 << 31) -#define NV04_TEXTURED_TRIANGLE_BLEND 0x00000310 -#define NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_MAP_SHIFT 0 -#define NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_MAP_MASK 0x0000000f -#define NV04_TEXTURED_TRIANGLE_BLEND_MASK_BIT_SHIFT 4 -#define NV04_TEXTURED_TRIANGLE_BLEND_MASK_BIT_MASK 0x00000030 -#define NV04_TEXTURED_TRIANGLE_BLEND_SHADE_MODE_SHIFT 6 -#define NV04_TEXTURED_TRIANGLE_BLEND_SHADE_MODE_MASK 0x000000c0 -#define NV04_TEXTURED_TRIANGLE_BLEND_SHADE_MODE_FLAT 0x00000040 -#define NV04_TEXTURED_TRIANGLE_BLEND_SHADE_MODE_GOURAUD 0x00000080 -#define NV04_TEXTURED_TRIANGLE_BLEND_SHADE_MODE_PHONG 0x000000c0 -#define NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_PERSPECTIVE_ENABLE (1 << 8) -#define NV04_TEXTURED_TRIANGLE_BLEND_SPECULAR_ENABLE (1 << 12) -#define NV04_TEXTURED_TRIANGLE_BLEND_FOG_ENABLE (1 << 16) -#define NV04_TEXTURED_TRIANGLE_BLEND_BLEND_ENABLE (1 << 20) -#define NV04_TEXTURED_TRIANGLE_BLEND_SRC_SHIFT 24 -#define NV04_TEXTURED_TRIANGLE_BLEND_SRC_MASK 0x0f000000 -#define NV04_TEXTURED_TRIANGLE_BLEND_DST_SHIFT 28 -#define NV04_TEXTURED_TRIANGLE_BLEND_DST_MASK 0xf0000000 -#define NV04_TEXTURED_TRIANGLE_CONTROL 0x00000314 -#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_REF_SHIFT 0 -#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_REF_MASK 0x000000ff -#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_FUNC_SHIFT 8 -#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_FUNC_MASK 0x00000f00 -#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_ENABLE (1 << 12) -#define NV04_TEXTURED_TRIANGLE_CONTROL_ORIGIN (1 << 13) -#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_ENABLE (1 << 14) -#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FUNC_SHIFT 16 -#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FUNC_MASK 0x000f0000 -#define NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_SHIFT 20 -#define NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_MASK 0x00300000 -#define NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_BOTH 0x00000000 -#define NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_NONE 0x00100000 -#define NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_CW 0x00200000 -#define NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_CCW 0x00300000 -#define NV04_TEXTURED_TRIANGLE_CONTROL_DITHER_ENABLE (1 << 22) -#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_PERSPECTIVE_ENABLE (1 << 23) -#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_WRITE (1 << 24) -#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FORMAT_SHIFT 30 -#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FORMAT_MASK 0xc0000000 -#define NV04_TEXTURED_TRIANGLE_FOGCOLOR 0x00000318 -#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_B_SHIFT 0 -#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_B_MASK 0x000000ff -#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_G_SHIFT 8 -#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_G_MASK 0x0000ff00 -#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_R_SHIFT 16 -#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_R_MASK 0x00ff0000 -#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_A_SHIFT 24 -#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_A_MASK 0xff000000 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SX(x) (0x00000400+((x)*32)) -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SX__SIZE 0x00000010 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SY(x) (0x00000404+((x)*32)) -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SY__SIZE 0x00000010 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SZ(x) (0x00000408+((x)*32)) -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SZ__SIZE 0x00000010 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_RHW(x) (0x0000040c+((x)*32)) -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_RHW__SIZE 0x00000010 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR(x) (0x00000410+((x)*32)) -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR__SIZE 0x00000010 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_B_SHIFT 0 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_B_MASK 0x000000ff -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_G_SHIFT 8 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_G_MASK 0x0000ff00 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_R_SHIFT 16 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_R_MASK 0x00ff0000 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_A_SHIFT 24 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_A_MASK 0xff000000 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR(x) (0x00000414+((x)*32)) -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR__SIZE 0x00000010 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_B_SHIFT 0 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_B_MASK 0x000000ff -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_G_SHIFT 8 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_G_MASK 0x0000ff00 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_R_SHIFT 16 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_R_MASK 0x00ff0000 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_FOG_SHIFT 24 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_FOG_MASK 0xff000000 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_TU(x) (0x00000418+((x)*32)) -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_TU__SIZE 0x00000010 -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_TV(x) (0x0000041c+((x)*32)) -#define NV04_TEXTURED_TRIANGLE_TLVERTEX_TV__SIZE 0x00000010 -#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE(x) (0x00000600+((x)*4)) -#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE__SIZE 0x00000040 -#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I0_SHIFT 0 -#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I0_MASK 0x0000000f -#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I1_SHIFT 4 -#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I1_MASK 0x000000f0 -#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I2_SHIFT 8 -#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I2_MASK 0x00000f00 -#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I3_SHIFT 12 -#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I3_MASK 0x0000f000 -#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I4_SHIFT 16 -#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I4_MASK 0x000f0000 -#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I5_SHIFT 20 -#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I5_MASK 0x00f00000 - - -#define NV10_TEXTURED_TRIANGLE 0x00000094 - - - -#define NV04_MULTITEX_TRIANGLE 0x00000055 - -#define NV04_MULTITEX_TRIANGLE_NOP 0x00000100 -#define NV04_MULTITEX_TRIANGLE_NOTIFY 0x00000104 -#define NV04_MULTITEX_TRIANGLE_DMA_NOTIFY 0x00000180 -#define NV04_MULTITEX_TRIANGLE_DMA_A 0x00000184 -#define NV04_MULTITEX_TRIANGLE_DMA_B 0x00000188 -#define NV04_MULTITEX_TRIANGLE_SURFACE 0x0000018c -#define NV04_MULTITEX_TRIANGLE_OFFSET(x) (0x00000308+((x)*4)) -#define NV04_MULTITEX_TRIANGLE_OFFSET__SIZE 0x00000002 -#define NV04_MULTITEX_TRIANGLE_FORMAT(x) (0x00000310+((x)*4)) -#define NV04_MULTITEX_TRIANGLE_FORMAT__SIZE 0x00000002 -#define NV04_MULTITEX_TRIANGLE_FORMAT_DMA_A (1 << 0) -#define NV04_MULTITEX_TRIANGLE_FORMAT_DMA_B (1 << 1) -#define NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_ZOH_SHIFT 4 -#define NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_ZOH_MASK 0x00000030 -#define NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_FOH_SHIFT 6 -#define NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_FOH_MASK 0x000000c0 -#define NV04_MULTITEX_TRIANGLE_FORMAT_COLOR_SHIFT 8 -#define NV04_MULTITEX_TRIANGLE_FORMAT_COLOR_MASK 0x00000f00 -#define NV04_MULTITEX_TRIANGLE_FORMAT_MIPMAP_LEVELS_SHIFT 12 -#define NV04_MULTITEX_TRIANGLE_FORMAT_MIPMAP_LEVELS_MASK 0x0000f000 -#define NV04_MULTITEX_TRIANGLE_FORMAT_BASE_SIZE_U_SHIFT 16 -#define NV04_MULTITEX_TRIANGLE_FORMAT_BASE_SIZE_U_MASK 0x000f0000 -#define NV04_MULTITEX_TRIANGLE_FORMAT_BASE_SIZE_V_SHIFT 20 -#define NV04_MULTITEX_TRIANGLE_FORMAT_BASE_SIZE_V_MASK 0x00f00000 -#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSU_SHIFT 24 -#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSU_MASK 0x07000000 -#define NV04_MULTITEX_TRIANGLE_FORMAT_WRAPU (1 << 27) -#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSV_SHIFT 28 -#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSV_MASK 0x70000000 -#define NV04_MULTITEX_TRIANGLE_FORMAT_WRAPV (1 << 31) -#define NV04_MULTITEX_TRIANGLE_FILTER(x) (0x00000318+((x)*4)) -#define NV04_MULTITEX_TRIANGLE_FILTER__SIZE 0x00000002 -#define NV04_MULTITEX_TRIANGLE_FILTER_KERNEL_SIZE_X_SHIFT 0 -#define NV04_MULTITEX_TRIANGLE_FILTER_KERNEL_SIZE_X_MASK 0x000000ff -#define NV04_MULTITEX_TRIANGLE_FILTER_KERNEL_SIZE_Y_SHIFT 8 -#define NV04_MULTITEX_TRIANGLE_FILTER_KERNEL_SIZE_Y_MASK 0x00007f00 -#define NV04_MULTITEX_TRIANGLE_FILTER_MIPMAP_DITHER_ENABLE (1 << 15) -#define NV04_MULTITEX_TRIANGLE_FILTER_MIPMAP_LODBIAS_SHIFT 16 -#define NV04_MULTITEX_TRIANGLE_FILTER_MIPMAP_LODBIAS_MASK 0x00ff0000 -#define NV04_MULTITEX_TRIANGLE_FILTER_MINIFY_SHIFT 24 -#define NV04_MULTITEX_TRIANGLE_FILTER_MINIFY_MASK 0x07000000 -#define NV04_MULTITEX_TRIANGLE_FILTER_ANISOTROPIC_MINIFY_ENABLE (1 << 27) -#define NV04_MULTITEX_TRIANGLE_FILTER_MAGNIFY_SHIFT 28 -#define NV04_MULTITEX_TRIANGLE_FILTER_MAGNIFY_MASK 0x70000000 -#define NV04_MULTITEX_TRIANGLE_FILTER_ANISOTROPIC_MAGNIFY_ENABLE (1 << 31) -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA(x) (0x00000320+((x)*12)) -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA__SIZE 0x00000002 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_INVERSE0 (1 << 0) -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_SHIFT 2 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_MASK 0x000000fc -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_ZERO 0x00000004 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_CONSTANT 0x00000008 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_PRIMARY_COLOR 0x0000000c -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_PREVIOUS 0x00000010 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_TEXTURE0 0x00000014 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_TEXTURE1 0x00000018 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_INVERSE1 (1 << 8) -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_SHIFT 10 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_MASK 0x0000fc00 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_ZERO 0x00000400 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_CONSTANT 0x00000800 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_PRIMARY_COLOR 0x00000c00 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_PREVIOUS 0x00001000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_TEXTURE0 0x00001400 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_TEXTURE1 0x00001800 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_INVERSE2 (1 << 16) -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_SHIFT 18 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_MASK 0x00fc0000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_ZERO 0x00040000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_CONSTANT 0x00080000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_PRIMARY_COLOR 0x000c0000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_PREVIOUS 0x00100000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_TEXTURE0 0x00140000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_TEXTURE1 0x00180000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_INVERSE3 (1 << 24) -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_SHIFT 26 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_MASK 0x1c000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_ZERO 0x04000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_CONSTANT 0x08000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_PRIMARY_COLOR 0x0c000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_PREVIOUS 0x10000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_TEXTURE0 0x14000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_TEXTURE1 0x18000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_SHIFT 29 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_MASK 0xe0000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_IDENTITY 0x20000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_SCALE2 0x40000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_SCALE4 0x60000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_BIAS 0x80000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_BIAS_SCALE2 0xe0000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR(x) (0x00000324+((x)*12)) -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR__SIZE 0x00000002 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_INVERSE0 (1 << 0) -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ALPHA0 (1 << 1) -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_SHIFT 2 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_MASK 0x000000fc -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_ZERO 0x00000004 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_CONSTANT 0x00000008 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_PRIMARY_COLOR 0x0000000c -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_PREVIOUS 0x00000010 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_TEXTURE0 0x00000014 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_TEXTURE1 0x00000018 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_INVERSE1 (1 << 8) -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ALPHA1 (1 << 9) -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_SHIFT 10 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_MASK 0x0000fc00 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_ZERO 0x00000400 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_CONSTANT 0x00000800 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_PRIMARY_COLOR 0x00000c00 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_PREVIOUS 0x00001000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_TEXTURE0 0x00001400 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_TEXTURE1 0x00001800 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_INVERSE2 (1 << 16) -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ALPHA2 (1 << 17) -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_SHIFT 18 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_MASK 0x00fc0000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_ZERO 0x00040000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_CONSTANT 0x00080000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_PRIMARY_COLOR 0x000c0000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_PREVIOUS 0x00100000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_TEXTURE0 0x00140000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_TEXTURE1 0x00180000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_INVERSE3 (1 << 24) -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ALPHA3 (1 << 25) -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_SHIFT 26 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_MASK 0x1c000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_ZERO 0x04000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_CONSTANT 0x08000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_PRIMARY_COLOR 0x0c000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_PREVIOUS 0x10000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_TEXTURE0 0x14000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_TEXTURE1 0x18000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_SHIFT 29 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_MASK 0xe0000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_IDENTITY 0x20000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_SCALE2 0x40000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_SCALE4 0x60000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_BIAS 0x80000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_BIAS_SCALE2 0xe0000000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR 0x00000334 -#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_B_SHIFT 0 -#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_B_MASK 0x000000ff -#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_G_SHIFT 8 -#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_G_MASK 0x0000ff00 -#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_R_SHIFT 16 -#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_R_MASK 0x00ff0000 -#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_A_SHIFT 24 -#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_A_MASK 0xff000000 -#define NV04_MULTITEX_TRIANGLE_BLEND 0x00000338 -#define NV04_MULTITEX_TRIANGLE_BLEND_MASK_BIT_SHIFT 4 -#define NV04_MULTITEX_TRIANGLE_BLEND_MASK_BIT_MASK 0x00000030 -#define NV04_MULTITEX_TRIANGLE_BLEND_SHADE_MODE_SHIFT 6 -#define NV04_MULTITEX_TRIANGLE_BLEND_SHADE_MODE_MASK 0x000000c0 -#define NV04_MULTITEX_TRIANGLE_BLEND_SHADE_MODE_FLAT 0x00000040 -#define NV04_MULTITEX_TRIANGLE_BLEND_SHADE_MODE_GOURAUD 0x00000080 -#define NV04_MULTITEX_TRIANGLE_BLEND_SHADE_MODE_PHONG 0x000000c0 -#define NV04_MULTITEX_TRIANGLE_BLEND_TEXTURE_PERSPECTIVE_ENABLE (1 << 8) -#define NV04_MULTITEX_TRIANGLE_BLEND_SPECULAR_ENABLE (1 << 12) -#define NV04_MULTITEX_TRIANGLE_BLEND_FOG_ENABLE (1 << 16) -#define NV04_MULTITEX_TRIANGLE_BLEND_BLEND_ENABLE (1 << 20) -#define NV04_MULTITEX_TRIANGLE_BLEND_SRC_SHIFT 24 -#define NV04_MULTITEX_TRIANGLE_BLEND_SRC_MASK 0x0f000000 -#define NV04_MULTITEX_TRIANGLE_BLEND_DST_SHIFT 28 -#define NV04_MULTITEX_TRIANGLE_BLEND_DST_MASK 0xf0000000 -#define NV04_MULTITEX_TRIANGLE_CONTROL0 0x0000033c -#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_REF_SHIFT 0 -#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_REF_MASK 0x000000ff -#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_FUNC_SHIFT 8 -#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_FUNC_MASK 0x00000f00 -#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_ENABLE (1 << 12) -#define NV04_MULTITEX_TRIANGLE_CONTROL0_ORIGIN (1 << 13) -#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_ENABLE (1 << 14) -#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FUNC_SHIFT 16 -#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FUNC_MASK 0x000f0000 -#define NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_SHIFT 20 -#define NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_MASK 0x00300000 -#define NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_BOTH 0x00000000 -#define NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_NONE 0x00100000 -#define NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_CW 0x00200000 -#define NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_CCW 0x00300000 -#define NV04_MULTITEX_TRIANGLE_CONTROL0_DITHER_ENABLE (1 << 22) -#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_PERSPECTIVE_ENABLE (1 << 23) -#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_WRITE (1 << 24) -#define NV04_MULTITEX_TRIANGLE_CONTROL0_STENCIL_WRITE (1 << 25) -#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_WRITE (1 << 26) -#define NV04_MULTITEX_TRIANGLE_CONTROL0_RED_WRITE (1 << 27) -#define NV04_MULTITEX_TRIANGLE_CONTROL0_GREEN_WRITE (1 << 28) -#define NV04_MULTITEX_TRIANGLE_CONTROL0_BLUE_WRITE (1 << 29) -#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FORMAT_SHIFT 30 -#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FORMAT_MASK 0xc0000000 -#define NV04_MULTITEX_TRIANGLE_CONTROL1 0x00000340 -#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_ENABLE (1 << 0) -#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_FUNC_SHIFT 4 -#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_FUNC_MASK 0x000000f0 -#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_REF_SHIFT 8 -#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_REF_MASK 0x0000ff00 -#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_MASK_READ_SHIFT 16 -#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_MASK_READ_MASK 0x00ff0000 -#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_MASK_WRITE_SHIFT 24 -#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_MASK_WRITE_MASK 0xff000000 -#define NV04_MULTITEX_TRIANGLE_CONTROL2 0x00000344 -#define NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_FAIL_SHIFT 0 -#define NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_FAIL_MASK 0x0000000f -#define NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_ZFAIL_SHIFT 4 -#define NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_ZFAIL_MASK 0x000000f0 -#define NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_ZPASS_SHIFT 8 -#define NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_ZPASS_MASK 0x00000f00 -#define NV04_MULTITEX_TRIANGLE_FOGCOLOR 0x00000348 -#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_B_SHIFT 0 -#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_B_MASK 0x000000ff -#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_G_SHIFT 8 -#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_G_MASK 0x0000ff00 -#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_R_SHIFT 16 -#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_R_MASK 0x00ff0000 -#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_A_SHIFT 24 -#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_A_MASK 0xff000000 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SX(x) (0x00000400+((x)*40)) -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SX__SIZE 0x00000008 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SY(x) (0x00000404+((x)*40)) -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SY__SIZE 0x00000008 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SZ(x) (0x00000408+((x)*40)) -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SZ__SIZE 0x00000008 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_RHW(x) (0x0000040c+((x)*40)) -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_RHW__SIZE 0x00000008 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR(x) (0x00000410+((x)*40)) -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR__SIZE 0x00000008 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_B_SHIFT 0 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_B_MASK 0x000000ff -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_G_SHIFT 8 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_G_MASK 0x0000ff00 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_R_SHIFT 16 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_R_MASK 0x00ff0000 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_A_SHIFT 24 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_A_MASK 0xff000000 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR(x) (0x00000414+((x)*40)) -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR__SIZE 0x00000008 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_B_SHIFT 0 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_B_MASK 0x000000ff -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_G_SHIFT 8 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_G_MASK 0x0000ff00 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_R_SHIFT 16 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_R_MASK 0x00ff0000 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_FOG_SHIFT 24 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_FOG_MASK 0xff000000 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TU0(x) (0x00000418+((x)*40)) -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TU0__SIZE 0x00000008 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TV0(x) (0x0000041c+((x)*40)) -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TV0__SIZE 0x00000008 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TU1(x) (0x00000420+((x)*40)) -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TU1__SIZE 0x00000008 -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TV1(x) (0x00000424+((x)*40)) -#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TV1__SIZE 0x00000008 -#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE(x) (0x00000540+((x)*4)) -#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE__SIZE 0x00000030 -#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I0_SHIFT 0 -#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I0_MASK 0x0000000f -#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I1_SHIFT 4 -#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I1_MASK 0x000000f0 -#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I2_SHIFT 8 -#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I2_MASK 0x00000f00 -#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I3_SHIFT 12 -#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I3_MASK 0x0000f000 -#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I4_SHIFT 16 -#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I4_MASK 0x000f0000 -#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I5_SHIFT 20 -#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I5_MASK 0x00f00000 - - -#define NV10_MULTITEX_TRIANGLE 0x00000095 - - - -#define NV10TCL 0x00000056 - -#define NV10TCL_NOP 0x00000100 -#define NV10TCL_NOTIFY 0x00000104 -#define NV10TCL_DMA_NOTIFY 0x00000180 -#define NV10TCL_DMA_IN_MEMORY0 0x00000184 -#define NV10TCL_DMA_IN_MEMORY1 0x00000188 -#define NV10TCL_DMA_VTXBUF0 0x0000018c -#define NV10TCL_DMA_IN_MEMORY2 0x00000194 -#define NV10TCL_DMA_IN_MEMORY3 0x00000198 -#define NV10TCL_RT_HORIZ 0x00000200 -#define NV10TCL_RT_HORIZ_X_SHIFT 0 -#define NV10TCL_RT_HORIZ_X_MASK 0x0000ffff -#define NV10TCL_RT_HORIZ_W_SHIFT 16 -#define NV10TCL_RT_HORIZ_W_MASK 0xffff0000 -#define NV10TCL_RT_VERT 0x00000204 -#define NV10TCL_RT_VERT_Y_SHIFT 0 -#define NV10TCL_RT_VERT_Y_MASK 0x0000ffff -#define NV10TCL_RT_VERT_H_SHIFT 16 -#define NV10TCL_RT_VERT_H_MASK 0xffff0000 -#define NV10TCL_RT_FORMAT 0x00000208 -#define NV10TCL_RT_FORMAT_TYPE_SHIFT 8 -#define NV10TCL_RT_FORMAT_TYPE_MASK 0x00000f00 -#define NV10TCL_RT_FORMAT_TYPE_LINEAR 0x00000100 -#define NV10TCL_RT_FORMAT_TYPE_SWIZZLED 0x00000200 -#define NV10TCL_RT_FORMAT_COLOR_SHIFT 0 -#define NV10TCL_RT_FORMAT_COLOR_MASK 0x0000001f -#define NV10TCL_RT_FORMAT_COLOR_R5G6B5 0x00000003 -#define NV10TCL_RT_FORMAT_COLOR_X8R8G8B8 0x00000005 -#define NV10TCL_RT_FORMAT_COLOR_A8R8G8B8 0x00000008 -#define NV10TCL_RT_FORMAT_COLOR_B8 0x00000009 -#define NV10TCL_RT_FORMAT_COLOR_UNKNOWN 0x0000000d -#define NV10TCL_RT_FORMAT_COLOR_X8B8G8R8 0x0000000f -#define NV10TCL_RT_FORMAT_COLOR_A8B8G8R8 0x00000010 -#define NV10TCL_RT_PITCH 0x0000020c -#define NV10TCL_RT_PITCH_COLOR_PITCH_SHIFT 0 -#define NV10TCL_RT_PITCH_COLOR_PITCH_MASK 0x0000ffff -#define NV10TCL_RT_PITCH_ZETA_PITCH_SHIFT 16 -#define NV10TCL_RT_PITCH_ZETA_PITCH_MASK 0xffff0000 -#define NV10TCL_COLOR_OFFSET 0x00000210 -#define NV10TCL_ZETA_OFFSET 0x00000214 -#define NV10TCL_TX_OFFSET(x) (0x00000218+((x)*4)) -#define NV10TCL_TX_OFFSET__SIZE 0x00000002 -#define NV10TCL_TX_FORMAT(x) (0x00000220+((x)*4)) -#define NV10TCL_TX_FORMAT__SIZE 0x00000002 -#define NV10TCL_TX_FORMAT_DMA0 (1 << 0) -#define NV10TCL_TX_FORMAT_DMA1 (1 << 1) -#define NV10TCL_TX_FORMAT_CUBE_MAP (1 << 2) -#define NV10TCL_TX_FORMAT_FORMAT_SHIFT 7 -#define NV10TCL_TX_FORMAT_FORMAT_MASK 0x00000f80 -#define NV10TCL_TX_FORMAT_FORMAT_L8 0x00000000 -#define NV10TCL_TX_FORMAT_FORMAT_A8 0x00000080 -#define NV10TCL_TX_FORMAT_FORMAT_A1R5G5B5 0x00000100 -#define NV10TCL_TX_FORMAT_FORMAT_A4R4G4B4 0x00000200 -#define NV10TCL_TX_FORMAT_FORMAT_R5G6B5 0x00000280 -#define NV10TCL_TX_FORMAT_FORMAT_A8R8G8B8 0x00000300 -#define NV10TCL_TX_FORMAT_FORMAT_X8R8G8B8 0x00000380 -#define NV10TCL_TX_FORMAT_FORMAT_INDEX8 0x00000580 -#define NV10TCL_TX_FORMAT_FORMAT_DXT1 0x00000600 -#define NV10TCL_TX_FORMAT_FORMAT_DXT3 0x00000700 -#define NV10TCL_TX_FORMAT_FORMAT_DXT5 0x00000780 -#define NV10TCL_TX_FORMAT_FORMAT_A1R5G5B5_RECT 0x00000800 -#define NV10TCL_TX_FORMAT_FORMAT_R5G6B5_RECT 0x00000880 -#define NV10TCL_TX_FORMAT_FORMAT_A8R8G8B8_RECT 0x00000900 -#define NV10TCL_TX_FORMAT_FORMAT_A8_RECT 0x00000980 -#define NV10TCL_TX_FORMAT_MIPMAP (1 << 15) -#define NV10TCL_TX_FORMAT_BASE_SIZE_U_SHIFT 16 -#define NV10TCL_TX_FORMAT_BASE_SIZE_U_MASK 0x000f0000 -#define NV10TCL_TX_FORMAT_BASE_SIZE_V_SHIFT 20 -#define NV10TCL_TX_FORMAT_BASE_SIZE_V_MASK 0x00f00000 -#define NV10TCL_TX_FORMAT_WRAP_S_SHIFT 24 -#define NV10TCL_TX_FORMAT_WRAP_S_MASK 0x0f000000 -#define NV10TCL_TX_FORMAT_WRAP_S_REPEAT 0x01000000 -#define NV10TCL_TX_FORMAT_WRAP_S_MIRRORED_REPEAT 0x02000000 -#define NV10TCL_TX_FORMAT_WRAP_S_CLAMP_TO_EDGE 0x03000000 -#define NV10TCL_TX_FORMAT_WRAP_S_CLAMP_TO_BORDER 0x04000000 -#define NV10TCL_TX_FORMAT_WRAP_S_CLAMP 0x05000000 -#define NV10TCL_TX_FORMAT_WRAP_T_SHIFT 28 -#define NV10TCL_TX_FORMAT_WRAP_T_MASK 0xf0000000 -#define NV10TCL_TX_FORMAT_WRAP_T_REPEAT 0x10000000 -#define NV10TCL_TX_FORMAT_WRAP_T_MIRRORED_REPEAT 0x20000000 -#define NV10TCL_TX_FORMAT_WRAP_T_CLAMP_TO_EDGE 0x30000000 -#define NV10TCL_TX_FORMAT_WRAP_T_CLAMP_TO_BORDER 0x40000000 -#define NV10TCL_TX_FORMAT_WRAP_T_CLAMP 0x50000000 -#define NV10TCL_TX_ENABLE(x) (0x00000228+((x)*4)) -#define NV10TCL_TX_ENABLE__SIZE 0x00000002 -#define NV10TCL_TX_ENABLE_CULL_SHIFT 0 -#define NV10TCL_TX_ENABLE_CULL_MASK 0x0000000f -#define NV10TCL_TX_ENABLE_CULL_DISABLED 0x00000000 -#define NV10TCL_TX_ENABLE_CULL_TEST_ALL 0x00000003 -#define NV10TCL_TX_ENABLE_CULL_TEST_ALPHA 0x00000004 -#define NV10TCL_TX_ENABLE_ANISOTROPY_SHIFT 4 -#define NV10TCL_TX_ENABLE_ANISOTROPY_MASK 0x00000030 -#define NV10TCL_TX_ENABLE_MIPMAP_MAX_LOD_SHIFT 14 -#define NV10TCL_TX_ENABLE_MIPMAP_MAX_LOD_MASK 0x0003c000 -#define NV10TCL_TX_ENABLE_MIPMAP_MIN_LOD_SHIFT 26 -#define NV10TCL_TX_ENABLE_MIPMAP_MIN_LOD_MASK 0x3c000000 -#define NV10TCL_TX_ENABLE_ENABLE (1 << 30) -#define NV10TCL_TX_NPOT_PITCH(x) (0x00000230+((x)*4)) -#define NV10TCL_TX_NPOT_PITCH__SIZE 0x00000002 -#define NV10TCL_TX_NPOT_PITCH_PITCH_SHIFT 16 -#define NV10TCL_TX_NPOT_PITCH_PITCH_MASK 0xffff0000 -#define NV10TCL_TX_NPOT_SIZE(x) (0x00000240+((x)*4)) -#define NV10TCL_TX_NPOT_SIZE__SIZE 0x00000002 -#define NV10TCL_TX_NPOT_SIZE_H_SHIFT 0 -#define NV10TCL_TX_NPOT_SIZE_H_MASK 0x0000ffff -#define NV10TCL_TX_NPOT_SIZE_W_SHIFT 16 -#define NV10TCL_TX_NPOT_SIZE_W_MASK 0xffff0000 -#define NV10TCL_TX_FILTER(x) (0x00000248+((x)*4)) -#define NV10TCL_TX_FILTER__SIZE 0x00000002 -#define NV10TCL_TX_FILTER_LOD_BIAS_SHIFT 8 -#define NV10TCL_TX_FILTER_LOD_BIAS_MASK 0x00000f00 -#define NV10TCL_TX_FILTER_MINIFY_SHIFT 24 -#define NV10TCL_TX_FILTER_MINIFY_MASK 0x0f000000 -#define NV10TCL_TX_FILTER_MINIFY_NEAREST 0x01000000 -#define NV10TCL_TX_FILTER_MINIFY_LINEAR 0x02000000 -#define NV10TCL_TX_FILTER_MINIFY_NEAREST_MIPMAP_NEAREST 0x03000000 -#define NV10TCL_TX_FILTER_MINIFY_LINEAR_MIPMAP_NEAREST 0x04000000 -#define NV10TCL_TX_FILTER_MINIFY_NEAREST_MIPMAP_LINEAR 0x05000000 -#define NV10TCL_TX_FILTER_MINIFY_LINEAR_MIPMAP_LINEAR 0x06000000 -#define NV10TCL_TX_FILTER_MAGNIFY_SHIFT 28 -#define NV10TCL_TX_FILTER_MAGNIFY_MASK 0xf0000000 -#define NV10TCL_TX_FILTER_MAGNIFY_NEAREST 0x10000000 -#define NV10TCL_TX_FILTER_MAGNIFY_LINEAR 0x20000000 -#define NV10TCL_TX_PALETTE_OFFSET(x) (0x00000250+((x)*4)) -#define NV10TCL_TX_PALETTE_OFFSET__SIZE 0x00000002 -#define NV10TCL_RC_IN_ALPHA(x) (0x00000260+((x)*4)) -#define NV10TCL_RC_IN_ALPHA__SIZE 0x00000002 -#define NV10TCL_RC_IN_ALPHA_D_INPUT_SHIFT 0 -#define NV10TCL_RC_IN_ALPHA_D_INPUT_MASK 0x0000000f -#define NV10TCL_RC_IN_ALPHA_D_INPUT_ZERO 0x00000000 -#define NV10TCL_RC_IN_ALPHA_D_INPUT_CONSTANT_COLOR0 0x00000001 -#define NV10TCL_RC_IN_ALPHA_D_INPUT_CONSTANT_COLOR1 0x00000002 -#define NV10TCL_RC_IN_ALPHA_D_INPUT_FOG 0x00000003 -#define NV10TCL_RC_IN_ALPHA_D_INPUT_PRIMARY_COLOR 0x00000004 -#define NV10TCL_RC_IN_ALPHA_D_INPUT_SECONDARY_COLOR 0x00000005 -#define NV10TCL_RC_IN_ALPHA_D_INPUT_TEXTURE0 0x00000008 -#define NV10TCL_RC_IN_ALPHA_D_INPUT_TEXTURE1 0x00000009 -#define NV10TCL_RC_IN_ALPHA_D_INPUT_SPARE0 0x0000000c -#define NV10TCL_RC_IN_ALPHA_D_INPUT_SPARE1 0x0000000d -#define NV10TCL_RC_IN_ALPHA_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e -#define NV10TCL_RC_IN_ALPHA_D_INPUT_E_TIMES_F 0x0000000f -#define NV10TCL_RC_IN_ALPHA_D_INPUT_TEXTURE2 0x0000000a -#define NV10TCL_RC_IN_ALPHA_D_INPUT_TEXTURE3 0x0000000b -#define NV10TCL_RC_IN_ALPHA_D_COMPONENT_USAGE (1 << 4) -#define NV10TCL_RC_IN_ALPHA_D_COMPONENT_USAGE_BLUE 0x00000000 -#define NV10TCL_RC_IN_ALPHA_D_COMPONENT_USAGE_ALPHA 0x00000010 -#define NV10TCL_RC_IN_ALPHA_D_MAPPING_SHIFT 5 -#define NV10TCL_RC_IN_ALPHA_D_MAPPING_MASK 0x000000e0 -#define NV10TCL_RC_IN_ALPHA_D_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV10TCL_RC_IN_ALPHA_D_MAPPING_UNSIGNED_INVERT 0x00000020 -#define NV10TCL_RC_IN_ALPHA_D_MAPPING_EXPAND_NORMAL 0x00000040 -#define NV10TCL_RC_IN_ALPHA_D_MAPPING_EXPAND_NEGATE 0x00000060 -#define NV10TCL_RC_IN_ALPHA_D_MAPPING_HALF_BIAS_NORMAL 0x00000080 -#define NV10TCL_RC_IN_ALPHA_D_MAPPING_HALF_BIAS_NEGATE 0x000000a0 -#define NV10TCL_RC_IN_ALPHA_D_MAPPING_SIGNED_IDENTITY 0x000000c0 -#define NV10TCL_RC_IN_ALPHA_D_MAPPING_SIGNED_NEGATE 0x000000e0 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_SHIFT 8 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_MASK 0x00000f00 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_ZERO 0x00000000 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_CONSTANT_COLOR0 0x00000100 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_CONSTANT_COLOR1 0x00000200 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_FOG 0x00000300 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_PRIMARY_COLOR 0x00000400 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_SECONDARY_COLOR 0x00000500 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_TEXTURE0 0x00000800 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_TEXTURE1 0x00000900 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_SPARE0 0x00000c00 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_SPARE1 0x00000d00 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_E_TIMES_F 0x00000f00 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_TEXTURE2 0x00000a00 -#define NV10TCL_RC_IN_ALPHA_C_INPUT_TEXTURE3 0x00000b00 -#define NV10TCL_RC_IN_ALPHA_C_COMPONENT_USAGE (1 << 12) -#define NV10TCL_RC_IN_ALPHA_C_COMPONENT_USAGE_BLUE 0x00000000 -#define NV10TCL_RC_IN_ALPHA_C_COMPONENT_USAGE_ALPHA 0x00001000 -#define NV10TCL_RC_IN_ALPHA_C_MAPPING_SHIFT 13 -#define NV10TCL_RC_IN_ALPHA_C_MAPPING_MASK 0x0000e000 -#define NV10TCL_RC_IN_ALPHA_C_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV10TCL_RC_IN_ALPHA_C_MAPPING_UNSIGNED_INVERT 0x00002000 -#define NV10TCL_RC_IN_ALPHA_C_MAPPING_EXPAND_NORMAL 0x00004000 -#define NV10TCL_RC_IN_ALPHA_C_MAPPING_EXPAND_NEGATE 0x00006000 -#define NV10TCL_RC_IN_ALPHA_C_MAPPING_HALF_BIAS_NORMAL 0x00008000 -#define NV10TCL_RC_IN_ALPHA_C_MAPPING_HALF_BIAS_NEGATE 0x0000a000 -#define NV10TCL_RC_IN_ALPHA_C_MAPPING_SIGNED_IDENTITY 0x0000c000 -#define NV10TCL_RC_IN_ALPHA_C_MAPPING_SIGNED_NEGATE 0x0000e000 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_SHIFT 16 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_MASK 0x000f0000 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_ZERO 0x00000000 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_CONSTANT_COLOR0 0x00010000 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_CONSTANT_COLOR1 0x00020000 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_FOG 0x00030000 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_PRIMARY_COLOR 0x00040000 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_SECONDARY_COLOR 0x00050000 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_TEXTURE0 0x00080000 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_TEXTURE1 0x00090000 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_SPARE0 0x000c0000 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_SPARE1 0x000d0000 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_E_TIMES_F 0x000f0000 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_TEXTURE2 0x000a0000 -#define NV10TCL_RC_IN_ALPHA_B_INPUT_TEXTURE3 0x000b0000 -#define NV10TCL_RC_IN_ALPHA_B_COMPONENT_USAGE (1 << 20) -#define NV10TCL_RC_IN_ALPHA_B_COMPONENT_USAGE_BLUE 0x00000000 -#define NV10TCL_RC_IN_ALPHA_B_COMPONENT_USAGE_ALPHA 0x00100000 -#define NV10TCL_RC_IN_ALPHA_B_MAPPING_SHIFT 21 -#define NV10TCL_RC_IN_ALPHA_B_MAPPING_MASK 0x00e00000 -#define NV10TCL_RC_IN_ALPHA_B_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV10TCL_RC_IN_ALPHA_B_MAPPING_UNSIGNED_INVERT 0x00200000 -#define NV10TCL_RC_IN_ALPHA_B_MAPPING_EXPAND_NORMAL 0x00400000 -#define NV10TCL_RC_IN_ALPHA_B_MAPPING_EXPAND_NEGATE 0x00600000 -#define NV10TCL_RC_IN_ALPHA_B_MAPPING_HALF_BIAS_NORMAL 0x00800000 -#define NV10TCL_RC_IN_ALPHA_B_MAPPING_HALF_BIAS_NEGATE 0x00a00000 -#define NV10TCL_RC_IN_ALPHA_B_MAPPING_SIGNED_IDENTITY 0x00c00000 -#define NV10TCL_RC_IN_ALPHA_B_MAPPING_SIGNED_NEGATE 0x00e00000 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_SHIFT 24 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_MASK 0x0f000000 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_ZERO 0x00000000 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_CONSTANT_COLOR0 0x01000000 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_CONSTANT_COLOR1 0x02000000 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_FOG 0x03000000 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_PRIMARY_COLOR 0x04000000 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_SECONDARY_COLOR 0x05000000 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_TEXTURE0 0x08000000 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_TEXTURE1 0x09000000 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_SPARE0 0x0c000000 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_SPARE1 0x0d000000 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_E_TIMES_F 0x0f000000 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_TEXTURE2 0x0a000000 -#define NV10TCL_RC_IN_ALPHA_A_INPUT_TEXTURE3 0x0b000000 -#define NV10TCL_RC_IN_ALPHA_A_COMPONENT_USAGE (1 << 28) -#define NV10TCL_RC_IN_ALPHA_A_COMPONENT_USAGE_BLUE 0x00000000 -#define NV10TCL_RC_IN_ALPHA_A_COMPONENT_USAGE_ALPHA 0x10000000 -#define NV10TCL_RC_IN_ALPHA_A_MAPPING_SHIFT 29 -#define NV10TCL_RC_IN_ALPHA_A_MAPPING_MASK 0xe0000000 -#define NV10TCL_RC_IN_ALPHA_A_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV10TCL_RC_IN_ALPHA_A_MAPPING_UNSIGNED_INVERT 0x20000000 -#define NV10TCL_RC_IN_ALPHA_A_MAPPING_EXPAND_NORMAL 0x40000000 -#define NV10TCL_RC_IN_ALPHA_A_MAPPING_EXPAND_NEGATE 0x60000000 -#define NV10TCL_RC_IN_ALPHA_A_MAPPING_HALF_BIAS_NORMAL 0x80000000 -#define NV10TCL_RC_IN_ALPHA_A_MAPPING_HALF_BIAS_NEGATE 0xa0000000 -#define NV10TCL_RC_IN_ALPHA_A_MAPPING_SIGNED_IDENTITY 0xc0000000 -#define NV10TCL_RC_IN_ALPHA_A_MAPPING_SIGNED_NEGATE 0xe0000000 -#define NV10TCL_RC_IN_RGB(x) (0x00000268+((x)*4)) -#define NV10TCL_RC_IN_RGB__SIZE 0x00000002 -#define NV10TCL_RC_IN_RGB_D_INPUT_SHIFT 0 -#define NV10TCL_RC_IN_RGB_D_INPUT_MASK 0x0000000f -#define NV10TCL_RC_IN_RGB_D_INPUT_ZERO 0x00000000 -#define NV10TCL_RC_IN_RGB_D_INPUT_CONSTANT_COLOR0 0x00000001 -#define NV10TCL_RC_IN_RGB_D_INPUT_CONSTANT_COLOR1 0x00000002 -#define NV10TCL_RC_IN_RGB_D_INPUT_FOG 0x00000003 -#define NV10TCL_RC_IN_RGB_D_INPUT_PRIMARY_COLOR 0x00000004 -#define NV10TCL_RC_IN_RGB_D_INPUT_SECONDARY_COLOR 0x00000005 -#define NV10TCL_RC_IN_RGB_D_INPUT_TEXTURE0 0x00000008 -#define NV10TCL_RC_IN_RGB_D_INPUT_TEXTURE1 0x00000009 -#define NV10TCL_RC_IN_RGB_D_INPUT_SPARE0 0x0000000c -#define NV10TCL_RC_IN_RGB_D_INPUT_SPARE1 0x0000000d -#define NV10TCL_RC_IN_RGB_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e -#define NV10TCL_RC_IN_RGB_D_INPUT_E_TIMES_F 0x0000000f -#define NV10TCL_RC_IN_RGB_D_INPUT_TEXTURE2 0x0000000a -#define NV10TCL_RC_IN_RGB_D_INPUT_TEXTURE3 0x0000000b -#define NV10TCL_RC_IN_RGB_D_COMPONENT_USAGE (1 << 4) -#define NV10TCL_RC_IN_RGB_D_COMPONENT_USAGE_RGB 0x00000000 -#define NV10TCL_RC_IN_RGB_D_COMPONENT_USAGE_ALPHA 0x00000010 -#define NV10TCL_RC_IN_RGB_D_MAPPING_SHIFT 5 -#define NV10TCL_RC_IN_RGB_D_MAPPING_MASK 0x000000e0 -#define NV10TCL_RC_IN_RGB_D_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV10TCL_RC_IN_RGB_D_MAPPING_UNSIGNED_INVERT 0x00000020 -#define NV10TCL_RC_IN_RGB_D_MAPPING_EXPAND_NORMAL 0x00000040 -#define NV10TCL_RC_IN_RGB_D_MAPPING_EXPAND_NEGATE 0x00000060 -#define NV10TCL_RC_IN_RGB_D_MAPPING_HALF_BIAS_NORMAL 0x00000080 -#define NV10TCL_RC_IN_RGB_D_MAPPING_HALF_BIAS_NEGATE 0x000000a0 -#define NV10TCL_RC_IN_RGB_D_MAPPING_SIGNED_IDENTITY 0x000000c0 -#define NV10TCL_RC_IN_RGB_D_MAPPING_SIGNED_NEGATE 0x000000e0 -#define NV10TCL_RC_IN_RGB_C_INPUT_SHIFT 8 -#define NV10TCL_RC_IN_RGB_C_INPUT_MASK 0x00000f00 -#define NV10TCL_RC_IN_RGB_C_INPUT_ZERO 0x00000000 -#define NV10TCL_RC_IN_RGB_C_INPUT_CONSTANT_COLOR0 0x00000100 -#define NV10TCL_RC_IN_RGB_C_INPUT_CONSTANT_COLOR1 0x00000200 -#define NV10TCL_RC_IN_RGB_C_INPUT_FOG 0x00000300 -#define NV10TCL_RC_IN_RGB_C_INPUT_PRIMARY_COLOR 0x00000400 -#define NV10TCL_RC_IN_RGB_C_INPUT_SECONDARY_COLOR 0x00000500 -#define NV10TCL_RC_IN_RGB_C_INPUT_TEXTURE0 0x00000800 -#define NV10TCL_RC_IN_RGB_C_INPUT_TEXTURE1 0x00000900 -#define NV10TCL_RC_IN_RGB_C_INPUT_SPARE0 0x00000c00 -#define NV10TCL_RC_IN_RGB_C_INPUT_SPARE1 0x00000d00 -#define NV10TCL_RC_IN_RGB_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 -#define NV10TCL_RC_IN_RGB_C_INPUT_E_TIMES_F 0x00000f00 -#define NV10TCL_RC_IN_RGB_C_INPUT_TEXTURE2 0x00000a00 -#define NV10TCL_RC_IN_RGB_C_INPUT_TEXTURE3 0x00000b00 -#define NV10TCL_RC_IN_RGB_C_COMPONENT_USAGE (1 << 12) -#define NV10TCL_RC_IN_RGB_C_COMPONENT_USAGE_RGB 0x00000000 -#define NV10TCL_RC_IN_RGB_C_COMPONENT_USAGE_ALPHA 0x00001000 -#define NV10TCL_RC_IN_RGB_C_MAPPING_SHIFT 13 -#define NV10TCL_RC_IN_RGB_C_MAPPING_MASK 0x0000e000 -#define NV10TCL_RC_IN_RGB_C_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV10TCL_RC_IN_RGB_C_MAPPING_UNSIGNED_INVERT 0x00002000 -#define NV10TCL_RC_IN_RGB_C_MAPPING_EXPAND_NORMAL 0x00004000 -#define NV10TCL_RC_IN_RGB_C_MAPPING_EXPAND_NEGATE 0x00006000 -#define NV10TCL_RC_IN_RGB_C_MAPPING_HALF_BIAS_NORMAL 0x00008000 -#define NV10TCL_RC_IN_RGB_C_MAPPING_HALF_BIAS_NEGATE 0x0000a000 -#define NV10TCL_RC_IN_RGB_C_MAPPING_SIGNED_IDENTITY 0x0000c000 -#define NV10TCL_RC_IN_RGB_C_MAPPING_SIGNED_NEGATE 0x0000e000 -#define NV10TCL_RC_IN_RGB_B_INPUT_SHIFT 16 -#define NV10TCL_RC_IN_RGB_B_INPUT_MASK 0x000f0000 -#define NV10TCL_RC_IN_RGB_B_INPUT_ZERO 0x00000000 -#define NV10TCL_RC_IN_RGB_B_INPUT_CONSTANT_COLOR0 0x00010000 -#define NV10TCL_RC_IN_RGB_B_INPUT_CONSTANT_COLOR1 0x00020000 -#define NV10TCL_RC_IN_RGB_B_INPUT_FOG 0x00030000 -#define NV10TCL_RC_IN_RGB_B_INPUT_PRIMARY_COLOR 0x00040000 -#define NV10TCL_RC_IN_RGB_B_INPUT_SECONDARY_COLOR 0x00050000 -#define NV10TCL_RC_IN_RGB_B_INPUT_TEXTURE0 0x00080000 -#define NV10TCL_RC_IN_RGB_B_INPUT_TEXTURE1 0x00090000 -#define NV10TCL_RC_IN_RGB_B_INPUT_SPARE0 0x000c0000 -#define NV10TCL_RC_IN_RGB_B_INPUT_SPARE1 0x000d0000 -#define NV10TCL_RC_IN_RGB_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 -#define NV10TCL_RC_IN_RGB_B_INPUT_E_TIMES_F 0x000f0000 -#define NV10TCL_RC_IN_RGB_B_INPUT_TEXTURE2 0x000a0000 -#define NV10TCL_RC_IN_RGB_B_INPUT_TEXTURE3 0x000b0000 -#define NV10TCL_RC_IN_RGB_B_COMPONENT_USAGE (1 << 20) -#define NV10TCL_RC_IN_RGB_B_COMPONENT_USAGE_RGB 0x00000000 -#define NV10TCL_RC_IN_RGB_B_COMPONENT_USAGE_ALPHA 0x00100000 -#define NV10TCL_RC_IN_RGB_B_MAPPING_SHIFT 21 -#define NV10TCL_RC_IN_RGB_B_MAPPING_MASK 0x00e00000 -#define NV10TCL_RC_IN_RGB_B_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV10TCL_RC_IN_RGB_B_MAPPING_UNSIGNED_INVERT 0x00200000 -#define NV10TCL_RC_IN_RGB_B_MAPPING_EXPAND_NORMAL 0x00400000 -#define NV10TCL_RC_IN_RGB_B_MAPPING_EXPAND_NEGATE 0x00600000 -#define NV10TCL_RC_IN_RGB_B_MAPPING_HALF_BIAS_NORMAL 0x00800000 -#define NV10TCL_RC_IN_RGB_B_MAPPING_HALF_BIAS_NEGATE 0x00a00000 -#define NV10TCL_RC_IN_RGB_B_MAPPING_SIGNED_IDENTITY 0x00c00000 -#define NV10TCL_RC_IN_RGB_B_MAPPING_SIGNED_NEGATE 0x00e00000 -#define NV10TCL_RC_IN_RGB_A_INPUT_SHIFT 24 -#define NV10TCL_RC_IN_RGB_A_INPUT_MASK 0x0f000000 -#define NV10TCL_RC_IN_RGB_A_INPUT_ZERO 0x00000000 -#define NV10TCL_RC_IN_RGB_A_INPUT_CONSTANT_COLOR0 0x01000000 -#define NV10TCL_RC_IN_RGB_A_INPUT_CONSTANT_COLOR1 0x02000000 -#define NV10TCL_RC_IN_RGB_A_INPUT_FOG 0x03000000 -#define NV10TCL_RC_IN_RGB_A_INPUT_PRIMARY_COLOR 0x04000000 -#define NV10TCL_RC_IN_RGB_A_INPUT_SECONDARY_COLOR 0x05000000 -#define NV10TCL_RC_IN_RGB_A_INPUT_TEXTURE0 0x08000000 -#define NV10TCL_RC_IN_RGB_A_INPUT_TEXTURE1 0x09000000 -#define NV10TCL_RC_IN_RGB_A_INPUT_SPARE0 0x0c000000 -#define NV10TCL_RC_IN_RGB_A_INPUT_SPARE1 0x0d000000 -#define NV10TCL_RC_IN_RGB_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 -#define NV10TCL_RC_IN_RGB_A_INPUT_E_TIMES_F 0x0f000000 -#define NV10TCL_RC_IN_RGB_A_INPUT_TEXTURE2 0x0a000000 -#define NV10TCL_RC_IN_RGB_A_INPUT_TEXTURE3 0x0b000000 -#define NV10TCL_RC_IN_RGB_A_COMPONENT_USAGE (1 << 28) -#define NV10TCL_RC_IN_RGB_A_COMPONENT_USAGE_RGB 0x00000000 -#define NV10TCL_RC_IN_RGB_A_COMPONENT_USAGE_ALPHA 0x10000000 -#define NV10TCL_RC_IN_RGB_A_MAPPING_SHIFT 29 -#define NV10TCL_RC_IN_RGB_A_MAPPING_MASK 0xe0000000 -#define NV10TCL_RC_IN_RGB_A_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV10TCL_RC_IN_RGB_A_MAPPING_UNSIGNED_INVERT 0x20000000 -#define NV10TCL_RC_IN_RGB_A_MAPPING_EXPAND_NORMAL 0x40000000 -#define NV10TCL_RC_IN_RGB_A_MAPPING_EXPAND_NEGATE 0x60000000 -#define NV10TCL_RC_IN_RGB_A_MAPPING_HALF_BIAS_NORMAL 0x80000000 -#define NV10TCL_RC_IN_RGB_A_MAPPING_HALF_BIAS_NEGATE 0xa0000000 -#define NV10TCL_RC_IN_RGB_A_MAPPING_SIGNED_IDENTITY 0xc0000000 -#define NV10TCL_RC_IN_RGB_A_MAPPING_SIGNED_NEGATE 0xe0000000 -#define NV10TCL_RC_COLOR(x) (0x00000270+((x)*4)) -#define NV10TCL_RC_COLOR__SIZE 0x00000002 -#define NV10TCL_RC_COLOR_B_SHIFT 0 -#define NV10TCL_RC_COLOR_B_MASK 0x000000ff -#define NV10TCL_RC_COLOR_G_SHIFT 8 -#define NV10TCL_RC_COLOR_G_MASK 0x0000ff00 -#define NV10TCL_RC_COLOR_R_SHIFT 16 -#define NV10TCL_RC_COLOR_R_MASK 0x00ff0000 -#define NV10TCL_RC_COLOR_A_SHIFT 24 -#define NV10TCL_RC_COLOR_A_MASK 0xff000000 -#define NV10TCL_RC_OUT_ALPHA(x) (0x00000278+((x)*4)) -#define NV10TCL_RC_OUT_ALPHA__SIZE 0x00000002 -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_SHIFT 0 -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_MASK 0x0000000f -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_ZERO 0x00000000 -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_CONSTANT_COLOR0 0x00000001 -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_CONSTANT_COLOR1 0x00000002 -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_FOG 0x00000003 -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_PRIMARY_COLOR 0x00000004 -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_SECONDARY_COLOR 0x00000005 -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE0 0x00000008 -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE1 0x00000009 -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_SPARE0 0x0000000c -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_SPARE1 0x0000000d -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_E_TIMES_F 0x0000000f -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE2 0x0000000a -#define NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE3 0x0000000b -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_SHIFT 4 -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_MASK 0x000000f0 -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_ZERO 0x00000000 -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_CONSTANT_COLOR0 0x00000010 -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_CONSTANT_COLOR1 0x00000020 -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_FOG 0x00000030 -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_PRIMARY_COLOR 0x00000040 -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_SECONDARY_COLOR 0x00000050 -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE0 0x00000080 -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE1 0x00000090 -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_SPARE0 0x000000c0 -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_SPARE1 0x000000d0 -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000000e0 -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_E_TIMES_F 0x000000f0 -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE2 0x000000a0 -#define NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE3 0x000000b0 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_SHIFT 8 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_MASK 0x00000f00 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_ZERO 0x00000000 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_CONSTANT_COLOR0 0x00000100 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_CONSTANT_COLOR1 0x00000200 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_FOG 0x00000300 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_PRIMARY_COLOR 0x00000400 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_SECONDARY_COLOR 0x00000500 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE0 0x00000800 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE1 0x00000900 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_SPARE0 0x00000c00 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_SPARE1 0x00000d00 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_E_TIMES_F 0x00000f00 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE2 0x00000a00 -#define NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE3 0x00000b00 -#define NV10TCL_RC_OUT_ALPHA_CD_DOT_PRODUCT (1 << 12) -#define NV10TCL_RC_OUT_ALPHA_AB_DOT_PRODUCT (1 << 13) -#define NV10TCL_RC_OUT_ALPHA_MUX_SUM (1 << 14) -#define NV10TCL_RC_OUT_ALPHA_BIAS (1 << 15) -#define NV10TCL_RC_OUT_ALPHA_BIAS_NONE 0x00000000 -#define NV10TCL_RC_OUT_ALPHA_BIAS_BIAS_BY_NEGATIVE_ONE_HALF 0x00008000 -#define NV10TCL_RC_OUT_ALPHA_SCALE_SHIFT 16 -#define NV10TCL_RC_OUT_ALPHA_SCALE_MASK 0x00030000 -#define NV10TCL_RC_OUT_ALPHA_SCALE_NONE 0x00000000 -#define NV10TCL_RC_OUT_ALPHA_SCALE_SCALE_BY_TWO 0x00010000 -#define NV10TCL_RC_OUT_ALPHA_SCALE_SCALE_BY_FOUR 0x00020000 -#define NV10TCL_RC_OUT_ALPHA_SCALE_SCALE_BY_ONE_HALF 0x00030000 -#define NV10TCL_RC_OUT_RGB(x) (0x00000280+((x)*4)) -#define NV10TCL_RC_OUT_RGB__SIZE 0x00000002 -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_SHIFT 0 -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_MASK 0x0000000f -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_ZERO 0x00000000 -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_CONSTANT_COLOR0 0x00000001 -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_CONSTANT_COLOR1 0x00000002 -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_FOG 0x00000003 -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_PRIMARY_COLOR 0x00000004 -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_SECONDARY_COLOR 0x00000005 -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE0 0x00000008 -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE1 0x00000009 -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_SPARE0 0x0000000c -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_SPARE1 0x0000000d -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_E_TIMES_F 0x0000000f -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE2 0x0000000a -#define NV10TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE3 0x0000000b -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_SHIFT 4 -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_MASK 0x000000f0 -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_ZERO 0x00000000 -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_CONSTANT_COLOR0 0x00000010 -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_CONSTANT_COLOR1 0x00000020 -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_FOG 0x00000030 -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_PRIMARY_COLOR 0x00000040 -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_SECONDARY_COLOR 0x00000050 -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE0 0x00000080 -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE1 0x00000090 -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_SPARE0 0x000000c0 -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_SPARE1 0x000000d0 -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000000e0 -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_E_TIMES_F 0x000000f0 -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE2 0x000000a0 -#define NV10TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE3 0x000000b0 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_SHIFT 8 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_MASK 0x00000f00 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_ZERO 0x00000000 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_CONSTANT_COLOR0 0x00000100 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_CONSTANT_COLOR1 0x00000200 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_FOG 0x00000300 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_PRIMARY_COLOR 0x00000400 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_SECONDARY_COLOR 0x00000500 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE0 0x00000800 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE1 0x00000900 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE0 0x00000c00 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE1 0x00000d00 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_E_TIMES_F 0x00000f00 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE2 0x00000a00 -#define NV10TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE3 0x00000b00 -#define NV10TCL_RC_OUT_RGB_CD_DOT_PRODUCT (1 << 12) -#define NV10TCL_RC_OUT_RGB_AB_DOT_PRODUCT (1 << 13) -#define NV10TCL_RC_OUT_RGB_MUX_SUM (1 << 14) -#define NV10TCL_RC_OUT_RGB_BIAS (1 << 15) -#define NV10TCL_RC_OUT_RGB_BIAS_NONE 0x00000000 -#define NV10TCL_RC_OUT_RGB_BIAS_BIAS_BY_NEGATIVE_ONE_HALF 0x00008000 -#define NV10TCL_RC_OUT_RGB_SCALE_SHIFT 16 -#define NV10TCL_RC_OUT_RGB_SCALE_MASK 0x00030000 -#define NV10TCL_RC_OUT_RGB_SCALE_NONE 0x00000000 -#define NV10TCL_RC_OUT_RGB_SCALE_SCALE_BY_TWO 0x00010000 -#define NV10TCL_RC_OUT_RGB_SCALE_SCALE_BY_FOUR 0x00020000 -#define NV10TCL_RC_OUT_RGB_SCALE_SCALE_BY_ONE_HALF 0x00030000 -#define NV10TCL_RC_OUT_RGB_OPERATION_SHIFT 27 -#define NV10TCL_RC_OUT_RGB_OPERATION_MASK 0x38000000 -#define NV10TCL_RC_FINAL0 0x00000288 -#define NV10TCL_RC_FINAL0_D_INPUT_SHIFT 0 -#define NV10TCL_RC_FINAL0_D_INPUT_MASK 0x0000000f -#define NV10TCL_RC_FINAL0_D_INPUT_ZERO 0x00000000 -#define NV10TCL_RC_FINAL0_D_INPUT_CONSTANT_COLOR0 0x00000001 -#define NV10TCL_RC_FINAL0_D_INPUT_CONSTANT_COLOR1 0x00000002 -#define NV10TCL_RC_FINAL0_D_INPUT_FOG 0x00000003 -#define NV10TCL_RC_FINAL0_D_INPUT_PRIMARY_COLOR 0x00000004 -#define NV10TCL_RC_FINAL0_D_INPUT_SECONDARY_COLOR 0x00000005 -#define NV10TCL_RC_FINAL0_D_INPUT_TEXTURE0 0x00000008 -#define NV10TCL_RC_FINAL0_D_INPUT_TEXTURE1 0x00000009 -#define NV10TCL_RC_FINAL0_D_INPUT_SPARE0 0x0000000c -#define NV10TCL_RC_FINAL0_D_INPUT_SPARE1 0x0000000d -#define NV10TCL_RC_FINAL0_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e -#define NV10TCL_RC_FINAL0_D_INPUT_E_TIMES_F 0x0000000f -#define NV10TCL_RC_FINAL0_D_INPUT_TEXTURE2 0x0000000a -#define NV10TCL_RC_FINAL0_D_INPUT_TEXTURE3 0x0000000b -#define NV10TCL_RC_FINAL0_D_COMPONENT_USAGE (1 << 4) -#define NV10TCL_RC_FINAL0_D_COMPONENT_USAGE_RGB 0x00000000 -#define NV10TCL_RC_FINAL0_D_COMPONENT_USAGE_ALPHA 0x00000010 -#define NV10TCL_RC_FINAL0_D_MAPPING_SHIFT 5 -#define NV10TCL_RC_FINAL0_D_MAPPING_MASK 0x000000e0 -#define NV10TCL_RC_FINAL0_D_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV10TCL_RC_FINAL0_D_MAPPING_UNSIGNED_INVERT 0x00000020 -#define NV10TCL_RC_FINAL0_D_MAPPING_EXPAND_NORMAL 0x00000040 -#define NV10TCL_RC_FINAL0_D_MAPPING_EXPAND_NEGATE 0x00000060 -#define NV10TCL_RC_FINAL0_D_MAPPING_HALF_BIAS_NORMAL 0x00000080 -#define NV10TCL_RC_FINAL0_D_MAPPING_HALF_BIAS_NEGATE 0x000000a0 -#define NV10TCL_RC_FINAL0_D_MAPPING_SIGNED_IDENTITY 0x000000c0 -#define NV10TCL_RC_FINAL0_D_MAPPING_SIGNED_NEGATE 0x000000e0 -#define NV10TCL_RC_FINAL0_C_INPUT_SHIFT 8 -#define NV10TCL_RC_FINAL0_C_INPUT_MASK 0x00000f00 -#define NV10TCL_RC_FINAL0_C_INPUT_ZERO 0x00000000 -#define NV10TCL_RC_FINAL0_C_INPUT_CONSTANT_COLOR0 0x00000100 -#define NV10TCL_RC_FINAL0_C_INPUT_CONSTANT_COLOR1 0x00000200 -#define NV10TCL_RC_FINAL0_C_INPUT_FOG 0x00000300 -#define NV10TCL_RC_FINAL0_C_INPUT_PRIMARY_COLOR 0x00000400 -#define NV10TCL_RC_FINAL0_C_INPUT_SECONDARY_COLOR 0x00000500 -#define NV10TCL_RC_FINAL0_C_INPUT_TEXTURE0 0x00000800 -#define NV10TCL_RC_FINAL0_C_INPUT_TEXTURE1 0x00000900 -#define NV10TCL_RC_FINAL0_C_INPUT_SPARE0 0x00000c00 -#define NV10TCL_RC_FINAL0_C_INPUT_SPARE1 0x00000d00 -#define NV10TCL_RC_FINAL0_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 -#define NV10TCL_RC_FINAL0_C_INPUT_E_TIMES_F 0x00000f00 -#define NV10TCL_RC_FINAL0_C_INPUT_TEXTURE2 0x00000a00 -#define NV10TCL_RC_FINAL0_C_INPUT_TEXTURE3 0x00000b00 -#define NV10TCL_RC_FINAL0_C_COMPONENT_USAGE (1 << 12) -#define NV10TCL_RC_FINAL0_C_COMPONENT_USAGE_RGB 0x00000000 -#define NV10TCL_RC_FINAL0_C_COMPONENT_USAGE_ALPHA 0x00001000 -#define NV10TCL_RC_FINAL0_C_MAPPING_SHIFT 13 -#define NV10TCL_RC_FINAL0_C_MAPPING_MASK 0x0000e000 -#define NV10TCL_RC_FINAL0_C_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV10TCL_RC_FINAL0_C_MAPPING_UNSIGNED_INVERT 0x00002000 -#define NV10TCL_RC_FINAL0_C_MAPPING_EXPAND_NORMAL 0x00004000 -#define NV10TCL_RC_FINAL0_C_MAPPING_EXPAND_NEGATE 0x00006000 -#define NV10TCL_RC_FINAL0_C_MAPPING_HALF_BIAS_NORMAL 0x00008000 -#define NV10TCL_RC_FINAL0_C_MAPPING_HALF_BIAS_NEGATE 0x0000a000 -#define NV10TCL_RC_FINAL0_C_MAPPING_SIGNED_IDENTITY 0x0000c000 -#define NV10TCL_RC_FINAL0_C_MAPPING_SIGNED_NEGATE 0x0000e000 -#define NV10TCL_RC_FINAL0_B_INPUT_SHIFT 16 -#define NV10TCL_RC_FINAL0_B_INPUT_MASK 0x000f0000 -#define NV10TCL_RC_FINAL0_B_INPUT_ZERO 0x00000000 -#define NV10TCL_RC_FINAL0_B_INPUT_CONSTANT_COLOR0 0x00010000 -#define NV10TCL_RC_FINAL0_B_INPUT_CONSTANT_COLOR1 0x00020000 -#define NV10TCL_RC_FINAL0_B_INPUT_FOG 0x00030000 -#define NV10TCL_RC_FINAL0_B_INPUT_PRIMARY_COLOR 0x00040000 -#define NV10TCL_RC_FINAL0_B_INPUT_SECONDARY_COLOR 0x00050000 -#define NV10TCL_RC_FINAL0_B_INPUT_TEXTURE0 0x00080000 -#define NV10TCL_RC_FINAL0_B_INPUT_TEXTURE1 0x00090000 -#define NV10TCL_RC_FINAL0_B_INPUT_SPARE0 0x000c0000 -#define NV10TCL_RC_FINAL0_B_INPUT_SPARE1 0x000d0000 -#define NV10TCL_RC_FINAL0_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 -#define NV10TCL_RC_FINAL0_B_INPUT_E_TIMES_F 0x000f0000 -#define NV10TCL_RC_FINAL0_B_INPUT_TEXTURE2 0x000a0000 -#define NV10TCL_RC_FINAL0_B_INPUT_TEXTURE3 0x000b0000 -#define NV10TCL_RC_FINAL0_B_COMPONENT_USAGE (1 << 20) -#define NV10TCL_RC_FINAL0_B_COMPONENT_USAGE_RGB 0x00000000 -#define NV10TCL_RC_FINAL0_B_COMPONENT_USAGE_ALPHA 0x00100000 -#define NV10TCL_RC_FINAL0_B_MAPPING_SHIFT 21 -#define NV10TCL_RC_FINAL0_B_MAPPING_MASK 0x00e00000 -#define NV10TCL_RC_FINAL0_B_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV10TCL_RC_FINAL0_B_MAPPING_UNSIGNED_INVERT 0x00200000 -#define NV10TCL_RC_FINAL0_B_MAPPING_EXPAND_NORMAL 0x00400000 -#define NV10TCL_RC_FINAL0_B_MAPPING_EXPAND_NEGATE 0x00600000 -#define NV10TCL_RC_FINAL0_B_MAPPING_HALF_BIAS_NORMAL 0x00800000 -#define NV10TCL_RC_FINAL0_B_MAPPING_HALF_BIAS_NEGATE 0x00a00000 -#define NV10TCL_RC_FINAL0_B_MAPPING_SIGNED_IDENTITY 0x00c00000 -#define NV10TCL_RC_FINAL0_B_MAPPING_SIGNED_NEGATE 0x00e00000 -#define NV10TCL_RC_FINAL0_A_INPUT_SHIFT 24 -#define NV10TCL_RC_FINAL0_A_INPUT_MASK 0x0f000000 -#define NV10TCL_RC_FINAL0_A_INPUT_ZERO 0x00000000 -#define NV10TCL_RC_FINAL0_A_INPUT_CONSTANT_COLOR0 0x01000000 -#define NV10TCL_RC_FINAL0_A_INPUT_CONSTANT_COLOR1 0x02000000 -#define NV10TCL_RC_FINAL0_A_INPUT_FOG 0x03000000 -#define NV10TCL_RC_FINAL0_A_INPUT_PRIMARY_COLOR 0x04000000 -#define NV10TCL_RC_FINAL0_A_INPUT_SECONDARY_COLOR 0x05000000 -#define NV10TCL_RC_FINAL0_A_INPUT_TEXTURE0 0x08000000 -#define NV10TCL_RC_FINAL0_A_INPUT_TEXTURE1 0x09000000 -#define NV10TCL_RC_FINAL0_A_INPUT_SPARE0 0x0c000000 -#define NV10TCL_RC_FINAL0_A_INPUT_SPARE1 0x0d000000 -#define NV10TCL_RC_FINAL0_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 -#define NV10TCL_RC_FINAL0_A_INPUT_E_TIMES_F 0x0f000000 -#define NV10TCL_RC_FINAL0_A_INPUT_TEXTURE2 0x0a000000 -#define NV10TCL_RC_FINAL0_A_INPUT_TEXTURE3 0x0b000000 -#define NV10TCL_RC_FINAL0_A_COMPONENT_USAGE (1 << 28) -#define NV10TCL_RC_FINAL0_A_COMPONENT_USAGE_RGB 0x00000000 -#define NV10TCL_RC_FINAL0_A_COMPONENT_USAGE_ALPHA 0x10000000 -#define NV10TCL_RC_FINAL0_A_MAPPING_SHIFT 29 -#define NV10TCL_RC_FINAL0_A_MAPPING_MASK 0xe0000000 -#define NV10TCL_RC_FINAL0_A_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV10TCL_RC_FINAL0_A_MAPPING_UNSIGNED_INVERT 0x20000000 -#define NV10TCL_RC_FINAL0_A_MAPPING_EXPAND_NORMAL 0x40000000 -#define NV10TCL_RC_FINAL0_A_MAPPING_EXPAND_NEGATE 0x60000000 -#define NV10TCL_RC_FINAL0_A_MAPPING_HALF_BIAS_NORMAL 0x80000000 -#define NV10TCL_RC_FINAL0_A_MAPPING_HALF_BIAS_NEGATE 0xa0000000 -#define NV10TCL_RC_FINAL0_A_MAPPING_SIGNED_IDENTITY 0xc0000000 -#define NV10TCL_RC_FINAL0_A_MAPPING_SIGNED_NEGATE 0xe0000000 -#define NV10TCL_RC_FINAL1 0x0000028c -#define NV10TCL_RC_FINAL1_COLOR_SUM_CLAMP (1 << 7) -#define NV10TCL_RC_FINAL1_G_INPUT_SHIFT 8 -#define NV10TCL_RC_FINAL1_G_INPUT_MASK 0x00000f00 -#define NV10TCL_RC_FINAL1_G_INPUT_ZERO 0x00000000 -#define NV10TCL_RC_FINAL1_G_INPUT_CONSTANT_COLOR0 0x00000100 -#define NV10TCL_RC_FINAL1_G_INPUT_CONSTANT_COLOR1 0x00000200 -#define NV10TCL_RC_FINAL1_G_INPUT_FOG 0x00000300 -#define NV10TCL_RC_FINAL1_G_INPUT_PRIMARY_COLOR 0x00000400 -#define NV10TCL_RC_FINAL1_G_INPUT_SECONDARY_COLOR 0x00000500 -#define NV10TCL_RC_FINAL1_G_INPUT_TEXTURE0 0x00000800 -#define NV10TCL_RC_FINAL1_G_INPUT_TEXTURE1 0x00000900 -#define NV10TCL_RC_FINAL1_G_INPUT_SPARE0 0x00000c00 -#define NV10TCL_RC_FINAL1_G_INPUT_SPARE1 0x00000d00 -#define NV10TCL_RC_FINAL1_G_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 -#define NV10TCL_RC_FINAL1_G_INPUT_E_TIMES_F 0x00000f00 -#define NV10TCL_RC_FINAL1_G_INPUT_TEXTURE2 0x00000a00 -#define NV10TCL_RC_FINAL1_G_INPUT_TEXTURE3 0x00000b00 -#define NV10TCL_RC_FINAL1_G_COMPONENT_USAGE (1 << 12) -#define NV10TCL_RC_FINAL1_G_COMPONENT_USAGE_RGB 0x00000000 -#define NV10TCL_RC_FINAL1_G_COMPONENT_USAGE_ALPHA 0x00001000 -#define NV10TCL_RC_FINAL1_G_MAPPING_SHIFT 13 -#define NV10TCL_RC_FINAL1_G_MAPPING_MASK 0x0000e000 -#define NV10TCL_RC_FINAL1_G_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV10TCL_RC_FINAL1_G_MAPPING_UNSIGNED_INVERT 0x00002000 -#define NV10TCL_RC_FINAL1_G_MAPPING_EXPAND_NORMAL 0x00004000 -#define NV10TCL_RC_FINAL1_G_MAPPING_EXPAND_NEGATE 0x00006000 -#define NV10TCL_RC_FINAL1_G_MAPPING_HALF_BIAS_NORMAL 0x00008000 -#define NV10TCL_RC_FINAL1_G_MAPPING_HALF_BIAS_NEGATE 0x0000a000 -#define NV10TCL_RC_FINAL1_G_MAPPING_SIGNED_IDENTITY 0x0000c000 -#define NV10TCL_RC_FINAL1_G_MAPPING_SIGNED_NEGATE 0x0000e000 -#define NV10TCL_RC_FINAL1_F_INPUT_SHIFT 16 -#define NV10TCL_RC_FINAL1_F_INPUT_MASK 0x000f0000 -#define NV10TCL_RC_FINAL1_F_INPUT_ZERO 0x00000000 -#define NV10TCL_RC_FINAL1_F_INPUT_CONSTANT_COLOR0 0x00010000 -#define NV10TCL_RC_FINAL1_F_INPUT_CONSTANT_COLOR1 0x00020000 -#define NV10TCL_RC_FINAL1_F_INPUT_FOG 0x00030000 -#define NV10TCL_RC_FINAL1_F_INPUT_PRIMARY_COLOR 0x00040000 -#define NV10TCL_RC_FINAL1_F_INPUT_SECONDARY_COLOR 0x00050000 -#define NV10TCL_RC_FINAL1_F_INPUT_TEXTURE0 0x00080000 -#define NV10TCL_RC_FINAL1_F_INPUT_TEXTURE1 0x00090000 -#define NV10TCL_RC_FINAL1_F_INPUT_SPARE0 0x000c0000 -#define NV10TCL_RC_FINAL1_F_INPUT_SPARE1 0x000d0000 -#define NV10TCL_RC_FINAL1_F_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 -#define NV10TCL_RC_FINAL1_F_INPUT_E_TIMES_F 0x000f0000 -#define NV10TCL_RC_FINAL1_F_INPUT_TEXTURE2 0x000a0000 -#define NV10TCL_RC_FINAL1_F_INPUT_TEXTURE3 0x000b0000 -#define NV10TCL_RC_FINAL1_F_COMPONENT_USAGE (1 << 20) -#define NV10TCL_RC_FINAL1_F_COMPONENT_USAGE_RGB 0x00000000 -#define NV10TCL_RC_FINAL1_F_COMPONENT_USAGE_ALPHA 0x00100000 -#define NV10TCL_RC_FINAL1_F_MAPPING_SHIFT 21 -#define NV10TCL_RC_FINAL1_F_MAPPING_MASK 0x00e00000 -#define NV10TCL_RC_FINAL1_F_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV10TCL_RC_FINAL1_F_MAPPING_UNSIGNED_INVERT 0x00200000 -#define NV10TCL_RC_FINAL1_F_MAPPING_EXPAND_NORMAL 0x00400000 -#define NV10TCL_RC_FINAL1_F_MAPPING_EXPAND_NEGATE 0x00600000 -#define NV10TCL_RC_FINAL1_F_MAPPING_HALF_BIAS_NORMAL 0x00800000 -#define NV10TCL_RC_FINAL1_F_MAPPING_HALF_BIAS_NEGATE 0x00a00000 -#define NV10TCL_RC_FINAL1_F_MAPPING_SIGNED_IDENTITY 0x00c00000 -#define NV10TCL_RC_FINAL1_F_MAPPING_SIGNED_NEGATE 0x00e00000 -#define NV10TCL_RC_FINAL1_E_INPUT_SHIFT 24 -#define NV10TCL_RC_FINAL1_E_INPUT_MASK 0x0f000000 -#define NV10TCL_RC_FINAL1_E_INPUT_ZERO 0x00000000 -#define NV10TCL_RC_FINAL1_E_INPUT_CONSTANT_COLOR0 0x01000000 -#define NV10TCL_RC_FINAL1_E_INPUT_CONSTANT_COLOR1 0x02000000 -#define NV10TCL_RC_FINAL1_E_INPUT_FOG 0x03000000 -#define NV10TCL_RC_FINAL1_E_INPUT_PRIMARY_COLOR 0x04000000 -#define NV10TCL_RC_FINAL1_E_INPUT_SECONDARY_COLOR 0x05000000 -#define NV10TCL_RC_FINAL1_E_INPUT_TEXTURE0 0x08000000 -#define NV10TCL_RC_FINAL1_E_INPUT_TEXTURE1 0x09000000 -#define NV10TCL_RC_FINAL1_E_INPUT_SPARE0 0x0c000000 -#define NV10TCL_RC_FINAL1_E_INPUT_SPARE1 0x0d000000 -#define NV10TCL_RC_FINAL1_E_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 -#define NV10TCL_RC_FINAL1_E_INPUT_E_TIMES_F 0x0f000000 -#define NV10TCL_RC_FINAL1_E_INPUT_TEXTURE2 0x0a000000 -#define NV10TCL_RC_FINAL1_E_INPUT_TEXTURE3 0x0b000000 -#define NV10TCL_RC_FINAL1_E_COMPONENT_USAGE (1 << 28) -#define NV10TCL_RC_FINAL1_E_COMPONENT_USAGE_RGB 0x00000000 -#define NV10TCL_RC_FINAL1_E_COMPONENT_USAGE_ALPHA 0x10000000 -#define NV10TCL_RC_FINAL1_E_MAPPING_SHIFT 29 -#define NV10TCL_RC_FINAL1_E_MAPPING_MASK 0xe0000000 -#define NV10TCL_RC_FINAL1_E_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV10TCL_RC_FINAL1_E_MAPPING_UNSIGNED_INVERT 0x20000000 -#define NV10TCL_RC_FINAL1_E_MAPPING_EXPAND_NORMAL 0x40000000 -#define NV10TCL_RC_FINAL1_E_MAPPING_EXPAND_NEGATE 0x60000000 -#define NV10TCL_RC_FINAL1_E_MAPPING_HALF_BIAS_NORMAL 0x80000000 -#define NV10TCL_RC_FINAL1_E_MAPPING_HALF_BIAS_NEGATE 0xa0000000 -#define NV10TCL_RC_FINAL1_E_MAPPING_SIGNED_IDENTITY 0xc0000000 -#define NV10TCL_RC_FINAL1_E_MAPPING_SIGNED_NEGATE 0xe0000000 -#define NV10TCL_LIGHT_MODEL 0x00000294 -#define NV10TCL_LIGHT_MODEL_VERTEX_SPECULAR (1 << 0) -#define NV10TCL_LIGHT_MODEL_SEPARATE_SPECULAR (1 << 1) -#define NV10TCL_LIGHT_MODEL_LOCAL_VIEWER (1 << 16) -#define NV10TCL_COLOR_MATERIAL 0x00000298 -#define NV10TCL_COLOR_MATERIAL_EMISSION (1 << 0) -#define NV10TCL_COLOR_MATERIAL_AMBIENT (1 << 1) -#define NV10TCL_COLOR_MATERIAL_DIFFUSE (1 << 2) -#define NV10TCL_COLOR_MATERIAL_SPECULAR (1 << 3) -#define NV10TCL_FOG_MODE 0x0000029c -#define NV10TCL_FOG_MODE_LINEAR 0x00002601 -#define NV10TCL_FOG_MODE_EXP 0x00000800 -#define NV10TCL_FOG_MODE_EXP_ABS 0x00000802 -#define NV10TCL_FOG_MODE_EXP2 0x00000803 -#define NV10TCL_FOG_COORD 0x000002a0 -#define NV10TCL_FOG_COORD_FOG 0x00000000 -#define NV10TCL_FOG_COORD_DIST_RADIAL 0x00000001 -#define NV10TCL_FOG_COORD_DIST_ORTHOGONAL 0x00000002 -#define NV10TCL_FOG_COORD_DIST_ORTHOGONAL_ABS 0x00000003 -#define NV10TCL_FOG_ENABLE 0x000002a4 -#define NV10TCL_FOG_COLOR 0x000002a8 -#define NV10TCL_FOG_COLOR_R_SHIFT 0 -#define NV10TCL_FOG_COLOR_R_MASK 0x000000ff -#define NV10TCL_FOG_COLOR_G_SHIFT 8 -#define NV10TCL_FOG_COLOR_G_MASK 0x0000ff00 -#define NV10TCL_FOG_COLOR_B_SHIFT 16 -#define NV10TCL_FOG_COLOR_B_MASK 0x00ff0000 -#define NV10TCL_FOG_COLOR_A_SHIFT 24 -#define NV10TCL_FOG_COLOR_A_MASK 0xff000000 -#define NV10TCL_VIEWPORT_CLIP_MODE 0x000002b4 -#define NV10TCL_VIEWPORT_CLIP_HORIZ(x) (0x000002c0+((x)*4)) -#define NV10TCL_VIEWPORT_CLIP_HORIZ__SIZE 0x00000008 -#define NV10TCL_VIEWPORT_CLIP_HORIZ_CLIP_L_SHIFT 0 -#define NV10TCL_VIEWPORT_CLIP_HORIZ_CLIP_L_MASK 0x000007ff -#define NV10TCL_VIEWPORT_CLIP_HORIZ_CLIP_LEFT_ENABLE (1 << 11) -#define NV10TCL_VIEWPORT_CLIP_HORIZ_CLIP_R_SHIFT 16 -#define NV10TCL_VIEWPORT_CLIP_HORIZ_CLIP_R_MASK 0x07ff0000 -#define NV10TCL_VIEWPORT_CLIP_HORIZ_CLIP_RIGHT_ENABLE (1 << 27) -#define NV10TCL_VIEWPORT_CLIP_VERT(x) (0x000002e0+((x)*4)) -#define NV10TCL_VIEWPORT_CLIP_VERT__SIZE 0x00000008 -#define NV10TCL_VIEWPORT_CLIP_VERT_CLIP_T_SHIFT 0 -#define NV10TCL_VIEWPORT_CLIP_VERT_CLIP_T_MASK 0x000007ff -#define NV10TCL_VIEWPORT_CLIP_VERT_CLIP_TOP_ENABLE (1 << 11) -#define NV10TCL_VIEWPORT_CLIP_VERT_CLIP_B_SHIFT 16 -#define NV10TCL_VIEWPORT_CLIP_VERT_CLIP_B_MASK 0x07ff0000 -#define NV10TCL_VIEWPORT_CLIP_VERT_CLIP_BOTTOM_ENABLE (1 << 27) -#define NV10TCL_ALPHA_FUNC_ENABLE 0x00000300 -#define NV10TCL_BLEND_FUNC_ENABLE 0x00000304 -#define NV10TCL_CULL_FACE_ENABLE 0x00000308 -#define NV10TCL_DEPTH_TEST_ENABLE 0x0000030c -#define NV10TCL_DITHER_ENABLE 0x00000310 -#define NV10TCL_LIGHTING_ENABLE 0x00000314 -#define NV10TCL_POINT_PARAMETERS_ENABLE 0x00000318 -#define NV10TCL_POINT_SMOOTH_ENABLE 0x0000031c -#define NV10TCL_LINE_SMOOTH_ENABLE 0x00000320 -#define NV10TCL_POLYGON_SMOOTH_ENABLE 0x00000324 -#define NV10TCL_VERTEX_WEIGHT_ENABLE 0x00000328 -#define NV10TCL_STENCIL_ENABLE 0x0000032c -#define NV10TCL_POLYGON_OFFSET_POINT_ENABLE 0x00000330 -#define NV10TCL_POLYGON_OFFSET_LINE_ENABLE 0x00000334 -#define NV10TCL_POLYGON_OFFSET_FILL_ENABLE 0x00000338 -#define NV10TCL_ALPHA_FUNC_FUNC 0x0000033c -#define NV10TCL_ALPHA_FUNC_FUNC_NEVER 0x00000200 -#define NV10TCL_ALPHA_FUNC_FUNC_LESS 0x00000201 -#define NV10TCL_ALPHA_FUNC_FUNC_EQUAL 0x00000202 -#define NV10TCL_ALPHA_FUNC_FUNC_LEQUAL 0x00000203 -#define NV10TCL_ALPHA_FUNC_FUNC_GREATER 0x00000204 -#define NV10TCL_ALPHA_FUNC_FUNC_NOTEQUAL 0x00000205 -#define NV10TCL_ALPHA_FUNC_FUNC_GEQUAL 0x00000206 -#define NV10TCL_ALPHA_FUNC_FUNC_ALWAYS 0x00000207 -#define NV10TCL_ALPHA_FUNC_REF 0x00000340 -#define NV10TCL_BLEND_FUNC_SRC 0x00000344 -#define NV10TCL_BLEND_FUNC_SRC_ZERO 0x00000000 -#define NV10TCL_BLEND_FUNC_SRC_ONE 0x00000001 -#define NV10TCL_BLEND_FUNC_SRC_SRC_COLOR 0x00000300 -#define NV10TCL_BLEND_FUNC_SRC_ONE_MINUS_SRC_COLOR 0x00000301 -#define NV10TCL_BLEND_FUNC_SRC_SRC_ALPHA 0x00000302 -#define NV10TCL_BLEND_FUNC_SRC_ONE_MINUS_SRC_ALPHA 0x00000303 -#define NV10TCL_BLEND_FUNC_SRC_DST_ALPHA 0x00000304 -#define NV10TCL_BLEND_FUNC_SRC_ONE_MINUS_DST_ALPHA 0x00000305 -#define NV10TCL_BLEND_FUNC_SRC_DST_COLOR 0x00000306 -#define NV10TCL_BLEND_FUNC_SRC_ONE_MINUS_DST_COLOR 0x00000307 -#define NV10TCL_BLEND_FUNC_SRC_SRC_ALPHA_SATURATE 0x00000308 -#define NV10TCL_BLEND_FUNC_SRC_CONSTANT_COLOR 0x00008001 -#define NV10TCL_BLEND_FUNC_SRC_ONE_MINUS_CONSTANT_COLOR 0x00008002 -#define NV10TCL_BLEND_FUNC_SRC_CONSTANT_ALPHA 0x00008003 -#define NV10TCL_BLEND_FUNC_SRC_ONE_MINUS_CONSTANT_ALPHA 0x00008004 -#define NV10TCL_BLEND_FUNC_DST 0x00000348 -#define NV10TCL_BLEND_FUNC_DST_ZERO 0x00000000 -#define NV10TCL_BLEND_FUNC_DST_ONE 0x00000001 -#define NV10TCL_BLEND_FUNC_DST_SRC_COLOR 0x00000300 -#define NV10TCL_BLEND_FUNC_DST_ONE_MINUS_SRC_COLOR 0x00000301 -#define NV10TCL_BLEND_FUNC_DST_SRC_ALPHA 0x00000302 -#define NV10TCL_BLEND_FUNC_DST_ONE_MINUS_SRC_ALPHA 0x00000303 -#define NV10TCL_BLEND_FUNC_DST_DST_ALPHA 0x00000304 -#define NV10TCL_BLEND_FUNC_DST_ONE_MINUS_DST_ALPHA 0x00000305 -#define NV10TCL_BLEND_FUNC_DST_DST_COLOR 0x00000306 -#define NV10TCL_BLEND_FUNC_DST_ONE_MINUS_DST_COLOR 0x00000307 -#define NV10TCL_BLEND_FUNC_DST_SRC_ALPHA_SATURATE 0x00000308 -#define NV10TCL_BLEND_FUNC_DST_CONSTANT_COLOR 0x00008001 -#define NV10TCL_BLEND_FUNC_DST_ONE_MINUS_CONSTANT_COLOR 0x00008002 -#define NV10TCL_BLEND_FUNC_DST_CONSTANT_ALPHA 0x00008003 -#define NV10TCL_BLEND_FUNC_DST_ONE_MINUS_CONSTANT_ALPHA 0x00008004 -#define NV10TCL_BLEND_COLOR 0x0000034c -#define NV10TCL_BLEND_COLOR_B_SHIFT 0 -#define NV10TCL_BLEND_COLOR_B_MASK 0x000000ff -#define NV10TCL_BLEND_COLOR_G_SHIFT 8 -#define NV10TCL_BLEND_COLOR_G_MASK 0x0000ff00 -#define NV10TCL_BLEND_COLOR_R_SHIFT 16 -#define NV10TCL_BLEND_COLOR_R_MASK 0x00ff0000 -#define NV10TCL_BLEND_COLOR_A_SHIFT 24 -#define NV10TCL_BLEND_COLOR_A_MASK 0xff000000 -#define NV10TCL_BLEND_EQUATION 0x00000350 -#define NV10TCL_BLEND_EQUATION_FUNC_ADD 0x00008006 -#define NV10TCL_BLEND_EQUATION_MIN 0x00008007 -#define NV10TCL_BLEND_EQUATION_MAX 0x00008008 -#define NV10TCL_BLEND_EQUATION_FUNC_SUBTRACT 0x0000800a -#define NV10TCL_BLEND_EQUATION_FUNC_REVERSE_SUBTRACT 0x0000800b -#define NV10TCL_DEPTH_FUNC 0x00000354 -#define NV10TCL_DEPTH_FUNC_NEVER 0x00000200 -#define NV10TCL_DEPTH_FUNC_LESS 0x00000201 -#define NV10TCL_DEPTH_FUNC_EQUAL 0x00000202 -#define NV10TCL_DEPTH_FUNC_LEQUAL 0x00000203 -#define NV10TCL_DEPTH_FUNC_GREATER 0x00000204 -#define NV10TCL_DEPTH_FUNC_NOTEQUAL 0x00000205 -#define NV10TCL_DEPTH_FUNC_GEQUAL 0x00000206 -#define NV10TCL_DEPTH_FUNC_ALWAYS 0x00000207 -#define NV10TCL_COLOR_MASK 0x00000358 -#define NV10TCL_COLOR_MASK_B (1 << 0) -#define NV10TCL_COLOR_MASK_G (1 << 8) -#define NV10TCL_COLOR_MASK_R (1 << 16) -#define NV10TCL_COLOR_MASK_A (1 << 24) -#define NV10TCL_DEPTH_WRITE_ENABLE 0x0000035c -#define NV10TCL_STENCIL_MASK 0x00000360 -#define NV10TCL_STENCIL_FUNC_FUNC 0x00000364 -#define NV10TCL_STENCIL_FUNC_FUNC_NEVER 0x00000200 -#define NV10TCL_STENCIL_FUNC_FUNC_LESS 0x00000201 -#define NV10TCL_STENCIL_FUNC_FUNC_EQUAL 0x00000202 -#define NV10TCL_STENCIL_FUNC_FUNC_LEQUAL 0x00000203 -#define NV10TCL_STENCIL_FUNC_FUNC_GREATER 0x00000204 -#define NV10TCL_STENCIL_FUNC_FUNC_NOTEQUAL 0x00000205 -#define NV10TCL_STENCIL_FUNC_FUNC_GEQUAL 0x00000206 -#define NV10TCL_STENCIL_FUNC_FUNC_ALWAYS 0x00000207 -#define NV10TCL_STENCIL_FUNC_REF 0x00000368 -#define NV10TCL_STENCIL_FUNC_MASK 0x0000036c -#define NV10TCL_STENCIL_OP_FAIL 0x00000370 -#define NV10TCL_STENCIL_OP_FAIL_ZERO 0x00000000 -#define NV10TCL_STENCIL_OP_FAIL_INVERT 0x0000150a -#define NV10TCL_STENCIL_OP_FAIL_KEEP 0x00001e00 -#define NV10TCL_STENCIL_OP_FAIL_REPLACE 0x00001e01 -#define NV10TCL_STENCIL_OP_FAIL_INCR 0x00001e02 -#define NV10TCL_STENCIL_OP_FAIL_DECR 0x00001e03 -#define NV10TCL_STENCIL_OP_FAIL_INCR_WRAP 0x00008507 -#define NV10TCL_STENCIL_OP_FAIL_DECR_WRAP 0x00008508 -#define NV10TCL_STENCIL_OP_ZFAIL 0x00000374 -#define NV10TCL_STENCIL_OP_ZFAIL_ZERO 0x00000000 -#define NV10TCL_STENCIL_OP_ZFAIL_INVERT 0x0000150a -#define NV10TCL_STENCIL_OP_ZFAIL_KEEP 0x00001e00 -#define NV10TCL_STENCIL_OP_ZFAIL_REPLACE 0x00001e01 -#define NV10TCL_STENCIL_OP_ZFAIL_INCR 0x00001e02 -#define NV10TCL_STENCIL_OP_ZFAIL_DECR 0x00001e03 -#define NV10TCL_STENCIL_OP_ZFAIL_INCR_WRAP 0x00008507 -#define NV10TCL_STENCIL_OP_ZFAIL_DECR_WRAP 0x00008508 -#define NV10TCL_STENCIL_OP_ZPASS 0x00000378 -#define NV10TCL_STENCIL_OP_ZPASS_ZERO 0x00000000 -#define NV10TCL_STENCIL_OP_ZPASS_INVERT 0x0000150a -#define NV10TCL_STENCIL_OP_ZPASS_KEEP 0x00001e00 -#define NV10TCL_STENCIL_OP_ZPASS_REPLACE 0x00001e01 -#define NV10TCL_STENCIL_OP_ZPASS_INCR 0x00001e02 -#define NV10TCL_STENCIL_OP_ZPASS_DECR 0x00001e03 -#define NV10TCL_STENCIL_OP_ZPASS_INCR_WRAP 0x00008507 -#define NV10TCL_STENCIL_OP_ZPASS_DECR_WRAP 0x00008508 -#define NV10TCL_SHADE_MODEL 0x0000037c -#define NV10TCL_SHADE_MODEL_FLAT 0x00001d00 -#define NV10TCL_SHADE_MODEL_SMOOTH 0x00001d01 -#define NV10TCL_LINE_WIDTH 0x00000380 -#define NV10TCL_POLYGON_OFFSET_FACTOR 0x00000384 -#define NV10TCL_POLYGON_OFFSET_UNITS 0x00000388 -#define NV10TCL_POLYGON_MODE_FRONT 0x0000038c -#define NV10TCL_POLYGON_MODE_FRONT_POINT 0x00001b00 -#define NV10TCL_POLYGON_MODE_FRONT_LINE 0x00001b01 -#define NV10TCL_POLYGON_MODE_FRONT_FILL 0x00001b02 -#define NV10TCL_POLYGON_MODE_BACK 0x00000390 -#define NV10TCL_POLYGON_MODE_BACK_POINT 0x00001b00 -#define NV10TCL_POLYGON_MODE_BACK_LINE 0x00001b01 -#define NV10TCL_POLYGON_MODE_BACK_FILL 0x00001b02 -#define NV10TCL_DEPTH_RANGE_NEAR 0x00000394 -#define NV10TCL_DEPTH_RANGE_FAR 0x00000398 -#define NV10TCL_CULL_FACE 0x0000039c -#define NV10TCL_CULL_FACE_FRONT 0x00000404 -#define NV10TCL_CULL_FACE_BACK 0x00000405 -#define NV10TCL_CULL_FACE_FRONT_AND_BACK 0x00000408 -#define NV10TCL_FRONT_FACE 0x000003a0 -#define NV10TCL_FRONT_FACE_CW 0x00000900 -#define NV10TCL_FRONT_FACE_CCW 0x00000901 -#define NV10TCL_NORMALIZE_ENABLE 0x000003a4 -#define NV10TCL_MATERIAL_FACTOR_R 0x000003a8 -#define NV10TCL_MATERIAL_FACTOR_G 0x000003ac -#define NV10TCL_MATERIAL_FACTOR_B 0x000003b0 -#define NV10TCL_MATERIAL_FACTOR_A 0x000003b4 -#define NV10TCL_SEPARATE_SPECULAR_ENABLE 0x000003b8 -#define NV10TCL_ENABLED_LIGHTS 0x000003bc -#define NV10TCL_ENABLED_LIGHTS_0_SHIFT 0 -#define NV10TCL_ENABLED_LIGHTS_0_MASK 0x00000003 -#define NV10TCL_ENABLED_LIGHTS_0_DISABLED 0x00000000 -#define NV10TCL_ENABLED_LIGHTS_0_NONPOSITIONAL 0x00000001 -#define NV10TCL_ENABLED_LIGHTS_0_POSITIONAL 0x00000002 -#define NV10TCL_ENABLED_LIGHTS_0_DIRECTIONAL 0x00000003 -#define NV10TCL_ENABLED_LIGHTS_1_SHIFT 2 -#define NV10TCL_ENABLED_LIGHTS_1_MASK 0x0000000c -#define NV10TCL_ENABLED_LIGHTS_1_DISABLED 0x00000000 -#define NV10TCL_ENABLED_LIGHTS_1_NONPOSITIONAL 0x00000004 -#define NV10TCL_ENABLED_LIGHTS_1_POSITIONAL 0x00000008 -#define NV10TCL_ENABLED_LIGHTS_1_DIRECTIONAL 0x0000000c -#define NV10TCL_ENABLED_LIGHTS_2_SHIFT 4 -#define NV10TCL_ENABLED_LIGHTS_2_MASK 0x00000030 -#define NV10TCL_ENABLED_LIGHTS_2_DISABLED 0x00000000 -#define NV10TCL_ENABLED_LIGHTS_2_NONPOSITIONAL 0x00000010 -#define NV10TCL_ENABLED_LIGHTS_2_POSITIONAL 0x00000020 -#define NV10TCL_ENABLED_LIGHTS_2_DIRECTIONAL 0x00000030 -#define NV10TCL_ENABLED_LIGHTS_3_SHIFT 6 -#define NV10TCL_ENABLED_LIGHTS_3_MASK 0x000000c0 -#define NV10TCL_ENABLED_LIGHTS_3_DISABLED 0x00000000 -#define NV10TCL_ENABLED_LIGHTS_3_NONPOSITIONAL 0x00000040 -#define NV10TCL_ENABLED_LIGHTS_3_POSITIONAL 0x00000080 -#define NV10TCL_ENABLED_LIGHTS_3_DIRECTIONAL 0x000000c0 -#define NV10TCL_ENABLED_LIGHTS_4_SHIFT 8 -#define NV10TCL_ENABLED_LIGHTS_4_MASK 0x00000300 -#define NV10TCL_ENABLED_LIGHTS_4_DISABLED 0x00000000 -#define NV10TCL_ENABLED_LIGHTS_4_NONPOSITIONAL 0x00000100 -#define NV10TCL_ENABLED_LIGHTS_4_POSITIONAL 0x00000200 -#define NV10TCL_ENABLED_LIGHTS_4_DIRECTIONAL 0x00000300 -#define NV10TCL_ENABLED_LIGHTS_5_SHIFT 10 -#define NV10TCL_ENABLED_LIGHTS_5_MASK 0x00000c00 -#define NV10TCL_ENABLED_LIGHTS_5_DISABLED 0x00000000 -#define NV10TCL_ENABLED_LIGHTS_5_NONPOSITIONAL 0x00000400 -#define NV10TCL_ENABLED_LIGHTS_5_POSITIONAL 0x00000800 -#define NV10TCL_ENABLED_LIGHTS_5_DIRECTIONAL 0x00000c00 -#define NV10TCL_ENABLED_LIGHTS_6_SHIFT 12 -#define NV10TCL_ENABLED_LIGHTS_6_MASK 0x00003000 -#define NV10TCL_ENABLED_LIGHTS_6_DISABLED 0x00000000 -#define NV10TCL_ENABLED_LIGHTS_6_NONPOSITIONAL 0x00001000 -#define NV10TCL_ENABLED_LIGHTS_6_POSITIONAL 0x00002000 -#define NV10TCL_ENABLED_LIGHTS_6_DIRECTIONAL 0x00003000 -#define NV10TCL_ENABLED_LIGHTS_7_SHIFT 14 -#define NV10TCL_ENABLED_LIGHTS_7_MASK 0x0000c000 -#define NV10TCL_ENABLED_LIGHTS_7_DISABLED 0x00000000 -#define NV10TCL_ENABLED_LIGHTS_7_NONPOSITIONAL 0x00004000 -#define NV10TCL_ENABLED_LIGHTS_7_POSITIONAL 0x00008000 -#define NV10TCL_ENABLED_LIGHTS_7_DIRECTIONAL 0x0000c000 -#define NV10TCL_TX_GEN_MODE_S(x) (0x000003c0+((x)*16)) -#define NV10TCL_TX_GEN_MODE_S__SIZE 0x00000002 -#define NV10TCL_TX_GEN_MODE_S_FALSE 0x00000000 -#define NV10TCL_TX_GEN_MODE_S_EYE_LINEAR 0x00002400 -#define NV10TCL_TX_GEN_MODE_S_OBJECT_LINEAR 0x00002401 -#define NV10TCL_TX_GEN_MODE_S_SPHERE_MAP 0x00002402 -#define NV10TCL_TX_GEN_MODE_S_NORMAL_MAP 0x00008511 -#define NV10TCL_TX_GEN_MODE_S_REFLECTION_MAP 0x00008512 -#define NV10TCL_TX_GEN_MODE_T(x) (0x000003c4+((x)*16)) -#define NV10TCL_TX_GEN_MODE_T__SIZE 0x00000002 -#define NV10TCL_TX_GEN_MODE_T_FALSE 0x00000000 -#define NV10TCL_TX_GEN_MODE_T_EYE_LINEAR 0x00002400 -#define NV10TCL_TX_GEN_MODE_T_OBJECT_LINEAR 0x00002401 -#define NV10TCL_TX_GEN_MODE_T_SPHERE_MAP 0x00002402 -#define NV10TCL_TX_GEN_MODE_T_NORMAL_MAP 0x00008511 -#define NV10TCL_TX_GEN_MODE_T_REFLECTION_MAP 0x00008512 -#define NV10TCL_TX_GEN_MODE_R(x) (0x000003c8+((x)*16)) -#define NV10TCL_TX_GEN_MODE_R__SIZE 0x00000002 -#define NV10TCL_TX_GEN_MODE_R_FALSE 0x00000000 -#define NV10TCL_TX_GEN_MODE_R_EYE_LINEAR 0x00002400 -#define NV10TCL_TX_GEN_MODE_R_OBJECT_LINEAR 0x00002401 -#define NV10TCL_TX_GEN_MODE_R_SPHERE_MAP 0x00002402 -#define NV10TCL_TX_GEN_MODE_R_NORMAL_MAP 0x00008511 -#define NV10TCL_TX_GEN_MODE_R_REFLECTION_MAP 0x00008512 -#define NV10TCL_TX_GEN_MODE_Q(x) (0x000003cc+((x)*16)) -#define NV10TCL_TX_GEN_MODE_Q__SIZE 0x00000002 -#define NV10TCL_TX_GEN_MODE_Q_FALSE 0x00000000 -#define NV10TCL_TX_GEN_MODE_Q_EYE_LINEAR 0x00002400 -#define NV10TCL_TX_GEN_MODE_Q_OBJECT_LINEAR 0x00002401 -#define NV10TCL_TX_GEN_MODE_Q_SPHERE_MAP 0x00002402 -#define NV10TCL_TX_GEN_MODE_Q_NORMAL_MAP 0x00008511 -#define NV10TCL_TX_GEN_MODE_Q_REFLECTION_MAP 0x00008512 -#define NV10TCL_TX_MATRIX_ENABLE(x) (0x000003e0+((x)*4)) -#define NV10TCL_TX_MATRIX_ENABLE__SIZE 0x00000002 -#define NV10TCL_VIEW_MATRIX_ENABLE 0x000003e8 -#define NV10TCL_VIEW_MATRIX_ENABLE_MODELVIEW1 (1 << 0) -#define NV10TCL_VIEW_MATRIX_ENABLE_MODELVIEW0 (1 << 1) -#define NV10TCL_VIEW_MATRIX_ENABLE_PROJECTION (1 << 2) -#define NV10TCL_POINT_SIZE 0x000003ec -#define NV10TCL_MODELVIEW0_MATRIX(x) (0x00000400+((x)*4)) -#define NV10TCL_MODELVIEW0_MATRIX__SIZE 0x00000010 -#define NV10TCL_MODELVIEW1_MATRIX(x) (0x00000440+((x)*4)) -#define NV10TCL_MODELVIEW1_MATRIX__SIZE 0x00000010 -#define NV10TCL_INVERSE_MODELVIEW0_MATRIX(x) (0x00000480+((x)*4)) -#define NV10TCL_INVERSE_MODELVIEW0_MATRIX__SIZE 0x00000010 -#define NV10TCL_INVERSE_MODELVIEW1_MATRIX(x) (0x000004c0+((x)*4)) -#define NV10TCL_INVERSE_MODELVIEW1_MATRIX__SIZE 0x00000010 -#define NV10TCL_PROJECTION_MATRIX(x) (0x00000500+((x)*4)) -#define NV10TCL_PROJECTION_MATRIX__SIZE 0x00000010 -#define NV10TCL_TX0_MATRIX(x) (0x00000540+((x)*4)) -#define NV10TCL_TX0_MATRIX__SIZE 0x00000010 -#define NV10TCL_TX1_MATRIX(x) (0x00000580+((x)*4)) -#define NV10TCL_TX1_MATRIX__SIZE 0x00000010 -#define NV10TCL_TX_GEN_COEFF_S_A(x) (0x00000600+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_S_A__SIZE 0x00000002 -#define NV10TCL_TX_GEN_COEFF_S_B(x) (0x00000604+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_S_B__SIZE 0x00000002 -#define NV10TCL_TX_GEN_COEFF_S_C(x) (0x00000608+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_S_C__SIZE 0x00000002 -#define NV10TCL_TX_GEN_COEFF_S_D(x) (0x0000060c+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_S_D__SIZE 0x00000002 -#define NV10TCL_TX_GEN_COEFF_T_A(x) (0x00000610+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_T_A__SIZE 0x00000002 -#define NV10TCL_TX_GEN_COEFF_T_B(x) (0x00000614+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_T_B__SIZE 0x00000002 -#define NV10TCL_TX_GEN_COEFF_T_C(x) (0x00000618+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_T_C__SIZE 0x00000002 -#define NV10TCL_TX_GEN_COEFF_T_D(x) (0x0000061c+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_T_D__SIZE 0x00000002 -#define NV10TCL_TX_GEN_COEFF_R_A(x) (0x00000620+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_R_A__SIZE 0x00000002 -#define NV10TCL_TX_GEN_COEFF_R_B(x) (0x00000624+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_R_B__SIZE 0x00000002 -#define NV10TCL_TX_GEN_COEFF_R_C(x) (0x00000628+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_R_C__SIZE 0x00000002 -#define NV10TCL_TX_GEN_COEFF_R_D(x) (0x0000062c+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_R_D__SIZE 0x00000002 -#define NV10TCL_TX_GEN_COEFF_Q_A(x) (0x00000630+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_Q_A__SIZE 0x00000002 -#define NV10TCL_TX_GEN_COEFF_Q_B(x) (0x00000634+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_Q_B__SIZE 0x00000002 -#define NV10TCL_TX_GEN_COEFF_Q_C(x) (0x00000638+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_Q_C__SIZE 0x00000002 -#define NV10TCL_TX_GEN_COEFF_Q_D(x) (0x0000063c+((x)*64)) -#define NV10TCL_TX_GEN_COEFF_Q_D__SIZE 0x00000002 -#define NV10TCL_FOG_EQUATION_CONSTANT 0x00000680 -#define NV10TCL_FOG_EQUATION_LINEAR 0x00000684 -#define NV10TCL_FOG_EQUATION_QUADRATIC 0x00000688 -#define NV10TCL_MATERIAL_SHININESS(x) (0x000006a0+((x)*4)) -#define NV10TCL_MATERIAL_SHININESS__SIZE 0x00000006 -#define NV10TCL_LIGHT_MODEL_AMBIENT_R 0x000006c4 -#define NV10TCL_LIGHT_MODEL_AMBIENT_G 0x000006c8 -#define NV10TCL_LIGHT_MODEL_AMBIENT_B 0x000006cc -#define NV10TCL_VIEWPORT_TRANSLATE_X 0x000006e8 -#define NV10TCL_VIEWPORT_TRANSLATE_Y 0x000006ec -#define NV10TCL_VIEWPORT_TRANSLATE_Z 0x000006f0 -#define NV10TCL_VIEWPORT_TRANSLATE_W 0x000006f4 -#define NV10TCL_POINT_PARAMETER(x) (0x000006f8+((x)*4)) -#define NV10TCL_POINT_PARAMETER__SIZE 0x00000008 -#define NV10TCL_LIGHT_AMBIENT_R(x) (0x00000800+((x)*128)) -#define NV10TCL_LIGHT_AMBIENT_R__SIZE 0x00000008 -#define NV10TCL_LIGHT_AMBIENT_G(x) (0x00000804+((x)*128)) -#define NV10TCL_LIGHT_AMBIENT_G__SIZE 0x00000008 -#define NV10TCL_LIGHT_AMBIENT_B(x) (0x00000808+((x)*128)) -#define NV10TCL_LIGHT_AMBIENT_B__SIZE 0x00000008 -#define NV10TCL_LIGHT_DIFFUSE_R(x) (0x0000080c+((x)*128)) -#define NV10TCL_LIGHT_DIFFUSE_R__SIZE 0x00000008 -#define NV10TCL_LIGHT_DIFFUSE_G(x) (0x00000810+((x)*128)) -#define NV10TCL_LIGHT_DIFFUSE_G__SIZE 0x00000008 -#define NV10TCL_LIGHT_DIFFUSE_B(x) (0x00000814+((x)*128)) -#define NV10TCL_LIGHT_DIFFUSE_B__SIZE 0x00000008 -#define NV10TCL_LIGHT_SPECULAR_R(x) (0x00000818+((x)*128)) -#define NV10TCL_LIGHT_SPECULAR_R__SIZE 0x00000008 -#define NV10TCL_LIGHT_SPECULAR_G(x) (0x0000081c+((x)*128)) -#define NV10TCL_LIGHT_SPECULAR_G__SIZE 0x00000008 -#define NV10TCL_LIGHT_SPECULAR_B(x) (0x00000820+((x)*128)) -#define NV10TCL_LIGHT_SPECULAR_B__SIZE 0x00000008 -#define NV10TCL_LIGHT_HALF_VECTOR_X(x) (0x00000828+((x)*128)) -#define NV10TCL_LIGHT_HALF_VECTOR_X__SIZE 0x00000008 -#define NV10TCL_LIGHT_HALF_VECTOR_Y(x) (0x0000082c+((x)*128)) -#define NV10TCL_LIGHT_HALF_VECTOR_Y__SIZE 0x00000008 -#define NV10TCL_LIGHT_HALF_VECTOR_Z(x) (0x00000830+((x)*128)) -#define NV10TCL_LIGHT_HALF_VECTOR_Z__SIZE 0x00000008 -#define NV10TCL_LIGHT_DIRECTION_X(x) (0x00000834+((x)*128)) -#define NV10TCL_LIGHT_DIRECTION_X__SIZE 0x00000008 -#define NV10TCL_LIGHT_DIRECTION_Y(x) (0x00000838+((x)*128)) -#define NV10TCL_LIGHT_DIRECTION_Y__SIZE 0x00000008 -#define NV10TCL_LIGHT_DIRECTION_Z(x) (0x0000083c+((x)*128)) -#define NV10TCL_LIGHT_DIRECTION_Z__SIZE 0x00000008 -#define NV10TCL_LIGHT_SPOT_CUTOFF_A(x) (0x00000840+((x)*128)) -#define NV10TCL_LIGHT_SPOT_CUTOFF_A__SIZE 0x00000008 -#define NV10TCL_LIGHT_SPOT_CUTOFF_B(x) (0x00000844+((x)*128)) -#define NV10TCL_LIGHT_SPOT_CUTOFF_B__SIZE 0x00000008 -#define NV10TCL_LIGHT_SPOT_CUTOFF_C(x) (0x00000848+((x)*128)) -#define NV10TCL_LIGHT_SPOT_CUTOFF_C__SIZE 0x00000008 -#define NV10TCL_LIGHT_SPOT_DIR_X(x) (0x0000084c+((x)*128)) -#define NV10TCL_LIGHT_SPOT_DIR_X__SIZE 0x00000008 -#define NV10TCL_LIGHT_SPOT_DIR_Y(x) (0x00000850+((x)*128)) -#define NV10TCL_LIGHT_SPOT_DIR_Y__SIZE 0x00000008 -#define NV10TCL_LIGHT_SPOT_DIR_Z(x) (0x00000854+((x)*128)) -#define NV10TCL_LIGHT_SPOT_DIR_Z__SIZE 0x00000008 -#define NV10TCL_LIGHT_SPOT_CUTOFF_D(x) (0x00000858+((x)*128)) -#define NV10TCL_LIGHT_SPOT_CUTOFF_D__SIZE 0x00000008 -#define NV10TCL_LIGHT_POSITION_X(x) (0x0000085c+((x)*128)) -#define NV10TCL_LIGHT_POSITION_X__SIZE 0x00000008 -#define NV10TCL_LIGHT_POSITION_Y(x) (0x00000860+((x)*128)) -#define NV10TCL_LIGHT_POSITION_Y__SIZE 0x00000008 -#define NV10TCL_LIGHT_POSITION_Z(x) (0x00000864+((x)*128)) -#define NV10TCL_LIGHT_POSITION_Z__SIZE 0x00000008 -#define NV10TCL_LIGHT_ATTENUATION_CONSTANT(x) (0x00000868+((x)*128)) -#define NV10TCL_LIGHT_ATTENUATION_CONSTANT__SIZE 0x00000008 -#define NV10TCL_LIGHT_ATTENUATION_LINEAR(x) (0x0000086c+((x)*128)) -#define NV10TCL_LIGHT_ATTENUATION_LINEAR__SIZE 0x00000008 -#define NV10TCL_LIGHT_ATTENUATION_QUADRATIC(x) (0x00000870+((x)*128)) -#define NV10TCL_LIGHT_ATTENUATION_QUADRATIC__SIZE 0x00000008 -#define NV10TCL_VERTEX_POS_3F_X 0x00000c00 -#define NV10TCL_VERTEX_POS_3F_Y 0x00000c04 -#define NV10TCL_VERTEX_POS_3F_Z 0x00000c08 -#define NV10TCL_VERTEX_POS_4F_X 0x00000c18 -#define NV10TCL_VERTEX_POS_4F_Y 0x00000c1c -#define NV10TCL_VERTEX_POS_4F_Z 0x00000c20 -#define NV10TCL_VERTEX_POS_4F_W 0x00000c24 -#define NV10TCL_VERTEX_NOR_3F_X 0x00000c30 -#define NV10TCL_VERTEX_NOR_3F_Y 0x00000c34 -#define NV10TCL_VERTEX_NOR_3F_Z 0x00000c38 -#define NV10TCL_VERTEX_NOR_3I_XY 0x00000c40 -#define NV10TCL_VERTEX_NOR_3I_XY_X_SHIFT 0 -#define NV10TCL_VERTEX_NOR_3I_XY_X_MASK 0x0000ffff -#define NV10TCL_VERTEX_NOR_3I_XY_Y_SHIFT 16 -#define NV10TCL_VERTEX_NOR_3I_XY_Y_MASK 0xffff0000 -#define NV10TCL_VERTEX_NOR_3I_Z 0x00000c44 -#define NV10TCL_VERTEX_NOR_3I_Z_Z_SHIFT 0 -#define NV10TCL_VERTEX_NOR_3I_Z_Z_MASK 0x0000ffff -#define NV10TCL_VERTEX_COL_4F_R 0x00000c50 -#define NV10TCL_VERTEX_COL_4F_G 0x00000c54 -#define NV10TCL_VERTEX_COL_4F_B 0x00000c58 -#define NV10TCL_VERTEX_COL_4F_A 0x00000c5c -#define NV10TCL_VERTEX_COL_3F_R 0x00000c60 -#define NV10TCL_VERTEX_COL_3F_G 0x00000c64 -#define NV10TCL_VERTEX_COL_3F_B 0x00000c68 -#define NV10TCL_VERTEX_COL_4I 0x00000c6c -#define NV10TCL_VERTEX_COL_4I_R_SHIFT 0 -#define NV10TCL_VERTEX_COL_4I_R_MASK 0x000000ff -#define NV10TCL_VERTEX_COL_4I_G_SHIFT 8 -#define NV10TCL_VERTEX_COL_4I_G_MASK 0x0000ff00 -#define NV10TCL_VERTEX_COL_4I_B_SHIFT 16 -#define NV10TCL_VERTEX_COL_4I_B_MASK 0x00ff0000 -#define NV10TCL_VERTEX_COL_4I_A_SHIFT 24 -#define NV10TCL_VERTEX_COL_4I_A_MASK 0xff000000 -#define NV10TCL_VERTEX_COL2_3F_R 0x00000c80 -#define NV10TCL_VERTEX_COL2_3F_G 0x00000c84 -#define NV10TCL_VERTEX_COL2_3F_B 0x00000c88 -#define NV10TCL_VERTEX_COL2_3I 0x00000c8c -#define NV10TCL_VERTEX_COL2_3I_R_SHIFT 0 -#define NV10TCL_VERTEX_COL2_3I_R_MASK 0x000000ff -#define NV10TCL_VERTEX_COL2_3I_G_SHIFT 8 -#define NV10TCL_VERTEX_COL2_3I_G_MASK 0x0000ff00 -#define NV10TCL_VERTEX_COL2_3I_B_SHIFT 16 -#define NV10TCL_VERTEX_COL2_3I_B_MASK 0x00ff0000 -#define NV10TCL_VERTEX_TX0_2F_S 0x00000c90 -#define NV10TCL_VERTEX_TX0_2F_T 0x00000c94 -#define NV10TCL_VERTEX_TX0_2I 0x00000c98 -#define NV10TCL_VERTEX_TX0_2I_S_SHIFT 0 -#define NV10TCL_VERTEX_TX0_2I_S_MASK 0x0000ffff -#define NV10TCL_VERTEX_TX0_2I_T_SHIFT 16 -#define NV10TCL_VERTEX_TX0_2I_T_MASK 0xffff0000 -#define NV10TCL_VERTEX_TX0_4F_S 0x00000ca0 -#define NV10TCL_VERTEX_TX0_4F_T 0x00000ca4 -#define NV10TCL_VERTEX_TX0_4F_R 0x00000ca8 -#define NV10TCL_VERTEX_TX0_4F_Q 0x00000cac -#define NV10TCL_VERTEX_TX0_4I_ST 0x00000cb0 -#define NV10TCL_VERTEX_TX0_4I_ST_S_SHIFT 0 -#define NV10TCL_VERTEX_TX0_4I_ST_S_MASK 0x0000ffff -#define NV10TCL_VERTEX_TX0_4I_ST_T_SHIFT 16 -#define NV10TCL_VERTEX_TX0_4I_ST_T_MASK 0xffff0000 -#define NV10TCL_VERTEX_TX0_4I_RQ 0x00000cb4 -#define NV10TCL_VERTEX_TX0_4I_RQ_R_SHIFT 0 -#define NV10TCL_VERTEX_TX0_4I_RQ_R_MASK 0x0000ffff -#define NV10TCL_VERTEX_TX0_4I_RQ_Q_SHIFT 16 -#define NV10TCL_VERTEX_TX0_4I_RQ_Q_MASK 0xffff0000 -#define NV10TCL_VERTEX_TX1_2F_S 0x00000cb8 -#define NV10TCL_VERTEX_TX1_2F_T 0x00000cbc -#define NV10TCL_VERTEX_TX1_2I 0x00000cc0 -#define NV10TCL_VERTEX_TX1_2I_S_SHIFT 0 -#define NV10TCL_VERTEX_TX1_2I_S_MASK 0x0000ffff -#define NV10TCL_VERTEX_TX1_2I_T_SHIFT 16 -#define NV10TCL_VERTEX_TX1_2I_T_MASK 0xffff0000 -#define NV10TCL_VERTEX_TX1_4F_S 0x00000cc8 -#define NV10TCL_VERTEX_TX1_4F_T 0x00000ccc -#define NV10TCL_VERTEX_TX1_4F_R 0x00000cd0 -#define NV10TCL_VERTEX_TX1_4F_Q 0x00000cd4 -#define NV10TCL_VERTEX_TX1_4I_ST 0x00000cd8 -#define NV10TCL_VERTEX_TX1_4I_ST_S_SHIFT 0 -#define NV10TCL_VERTEX_TX1_4I_ST_S_MASK 0x0000ffff -#define NV10TCL_VERTEX_TX1_4I_ST_T_SHIFT 16 -#define NV10TCL_VERTEX_TX1_4I_ST_T_MASK 0xffff0000 -#define NV10TCL_VERTEX_TX1_4I_RQ 0x00000cdc -#define NV10TCL_VERTEX_TX1_4I_RQ_R_SHIFT 0 -#define NV10TCL_VERTEX_TX1_4I_RQ_R_MASK 0x0000ffff -#define NV10TCL_VERTEX_TX1_4I_RQ_Q_SHIFT 16 -#define NV10TCL_VERTEX_TX1_4I_RQ_Q_MASK 0xffff0000 -#define NV10TCL_VERTEX_FOG_1F 0x00000ce0 -#define NV10TCL_VERTEX_WGH_1F 0x00000ce4 -#define NV10TCL_EDGEFLAG_ENABLE 0x00000cec -#define NV10TCL_VERTEX_ARRAY_VALIDATE 0x00000cf0 -#define NV10TCL_VTXBUF_ADDRESS(x) (0x00000d00+((x)*8)) -#define NV10TCL_VTXBUF_ADDRESS__SIZE 0x00000008 -#define NV10TCL_VTXFMT(x) (0x00000d04+((x)*8)) -#define NV10TCL_VTXFMT__SIZE 0x00000008 -#define NV10TCL_VTXFMT_TYPE_SHIFT 0 -#define NV10TCL_VTXFMT_TYPE_MASK 0x0000000f -#define NV10TCL_VTXFMT_TYPE_BYTE_BGRA 0x00000000 -#define NV10TCL_VTXFMT_TYPE_SHORT 0x00000001 -#define NV10TCL_VTXFMT_TYPE_FLOAT 0x00000002 -#define NV10TCL_VTXFMT_TYPE_BYTE_RGBA 0x00000004 -#define NV10TCL_VTXFMT_FIELDS_SHIFT 4 -#define NV10TCL_VTXFMT_FIELDS_MASK 0x000000f0 -#define NV10TCL_VTXFMT_STRIDE_SHIFT 8 -#define NV10TCL_VTXFMT_STRIDE_MASK 0x0000ff00 -#define NV10TCL_VTXFMT_POS_HOMOGENEOUS (1 << 24) -#define NV10TCL_VERTEX_BEGIN_END 0x00000dfc -#define NV10TCL_VERTEX_BEGIN_END_STOP 0x00000000 -#define NV10TCL_VERTEX_BEGIN_END_POINTS 0x00000001 -#define NV10TCL_VERTEX_BEGIN_END_LINES 0x00000002 -#define NV10TCL_VERTEX_BEGIN_END_LINE_LOOP 0x00000003 -#define NV10TCL_VERTEX_BEGIN_END_LINE_STRIP 0x00000004 -#define NV10TCL_VERTEX_BEGIN_END_TRIANGLES 0x00000005 -#define NV10TCL_VERTEX_BEGIN_END_TRIANGLE_STRIP 0x00000006 -#define NV10TCL_VERTEX_BEGIN_END_TRIANGLE_FAN 0x00000007 -#define NV10TCL_VERTEX_BEGIN_END_QUADS 0x00000008 -#define NV10TCL_VERTEX_BEGIN_END_QUAD_STRIP 0x00000009 -#define NV10TCL_VERTEX_BEGIN_END_POLYGON 0x0000000a -#define NV10TCL_VB_ELEMENT_U16 0x00000e00 -#define NV10TCL_VB_ELEMENT_U16_I0_SHIFT 0 -#define NV10TCL_VB_ELEMENT_U16_I0_MASK 0x0000ffff -#define NV10TCL_VB_ELEMENT_U16_I1_SHIFT 16 -#define NV10TCL_VB_ELEMENT_U16_I1_MASK 0xffff0000 -#define NV10TCL_VB_ELEMENT_U32 0x00001100 -#define NV10TCL_VERTEX_BUFFER_BEGIN_END 0x000013fc -#define NV10TCL_VERTEX_BUFFER_BEGIN_END_STOP 0x00000000 -#define NV10TCL_VERTEX_BUFFER_BEGIN_END_POINTS 0x00000001 -#define NV10TCL_VERTEX_BUFFER_BEGIN_END_LINES 0x00000002 -#define NV10TCL_VERTEX_BUFFER_BEGIN_END_LINE_LOOP 0x00000003 -#define NV10TCL_VERTEX_BUFFER_BEGIN_END_LINE_STRIP 0x00000004 -#define NV10TCL_VERTEX_BUFFER_BEGIN_END_TRIANGLES 0x00000005 -#define NV10TCL_VERTEX_BUFFER_BEGIN_END_TRIANGLE_STRIP 0x00000006 -#define NV10TCL_VERTEX_BUFFER_BEGIN_END_TRIANGLE_FAN 0x00000007 -#define NV10TCL_VERTEX_BUFFER_BEGIN_END_QUADS 0x00000008 -#define NV10TCL_VERTEX_BUFFER_BEGIN_END_QUAD_STRIP 0x00000009 -#define NV10TCL_VERTEX_BUFFER_BEGIN_END_POLYGON 0x0000000a -#define NV10TCL_VERTEX_BUFFER_DRAW_ARRAYS 0x00001400 -#define NV10TCL_VERTEX_BUFFER_DRAW_ARRAYS_FIRST_SHIFT 0 -#define NV10TCL_VERTEX_BUFFER_DRAW_ARRAYS_FIRST_MASK 0x0000ffff -#define NV10TCL_VERTEX_BUFFER_DRAW_ARRAYS_LAST_SHIFT 24 -#define NV10TCL_VERTEX_BUFFER_DRAW_ARRAYS_LAST_MASK 0xff000000 -#define NV10TCL_VERTEX_ARRAY_DATA 0x00001800 - - -#define NV11TCL 0x00000096 - -#define NV11TCL_COLOR_LOGIC_OP_ENABLE 0x00000d40 -#define NV11TCL_COLOR_LOGIC_OP_OP 0x00000d44 -#define NV11TCL_COLOR_LOGIC_OP_OP_CLEAR 0x00001500 -#define NV11TCL_COLOR_LOGIC_OP_OP_AND 0x00001501 -#define NV11TCL_COLOR_LOGIC_OP_OP_AND_REVERSE 0x00001502 -#define NV11TCL_COLOR_LOGIC_OP_OP_COPY 0x00001503 -#define NV11TCL_COLOR_LOGIC_OP_OP_AND_INVERTED 0x00001504 -#define NV11TCL_COLOR_LOGIC_OP_OP_NOOP 0x00001505 -#define NV11TCL_COLOR_LOGIC_OP_OP_XOR 0x00001506 -#define NV11TCL_COLOR_LOGIC_OP_OP_OR 0x00001507 -#define NV11TCL_COLOR_LOGIC_OP_OP_NOR 0x00001508 -#define NV11TCL_COLOR_LOGIC_OP_OP_EQUIV 0x00001509 -#define NV11TCL_COLOR_LOGIC_OP_OP_INVERT 0x0000150a -#define NV11TCL_COLOR_LOGIC_OP_OP_OR_REVERSE 0x0000150b -#define NV11TCL_COLOR_LOGIC_OP_OP_COPY_INVERTED 0x0000150c -#define NV11TCL_COLOR_LOGIC_OP_OP_OR_INVERTED 0x0000150d -#define NV11TCL_COLOR_LOGIC_OP_OP_NAND 0x0000150e -#define NV11TCL_COLOR_LOGIC_OP_OP_SET 0x0000150f - - -#define NV17TCL 0x00000099 - -#define NV17TCL_DMA_IN_MEMORY4 0x000001ac -#define NV17TCL_DMA_IN_MEMORY5 0x000001b0 -#define NV17TCL_COLOR_MASK_ENABLE 0x000002bc -#define NV17TCL_ZCLEAR_ENABLE 0x000003f8 -#define NV17TCL_ZCLEAR_VALUE 0x000003fc -#define NV17TCL_ZCLEAR_VALUE_DEPTH_SHIFT 8 -#define NV17TCL_ZCLEAR_VALUE_DEPTH_MASK 0xffffff00 -#define NV17TCL_ZCLEAR_VALUE_SEQUENCE_SHIFT 0 -#define NV17TCL_ZCLEAR_VALUE_SEQUENCE_MASK 0x000000ff -#define NV17TCL_LMA_DEPTH_BUFFER_PITCH 0x00000d5c -#define NV17TCL_LMA_DEPTH_BUFFER_OFFSET 0x00000d60 -#define NV17TCL_LMA_DEPTH_FILL_VALUE 0x00000d68 -#define NV17TCL_LMA_DEPTH_BUFFER_CLEAR 0x00000d6c -#define NV17TCL_LMA_DEPTH_WINDOW_X 0x00001638 -#define NV17TCL_LMA_DEPTH_WINDOW_Y 0x0000163c -#define NV17TCL_LMA_DEPTH_WINDOW_Z 0x00001640 -#define NV17TCL_LMA_DEPTH_WINDOW_W 0x00001644 -#define NV17TCL_LMA_DEPTH_ENABLE 0x00001658 - - -#define NV03_CONTEXT_SURFACES_2D 0x00000058 - -#define NV03_CONTEXT_SURFACES_2D_SYNCHRONIZE 0x00000100 -#define NV03_CONTEXT_SURFACES_2D_DMA_NOTIFY 0x00000180 -#define NV03_CONTEXT_SURFACES_2D_DMA_SOURCE 0x00000184 -#define NV03_CONTEXT_SURFACES_2D_DMA_DESTIN 0x00000188 -#define NV03_CONTEXT_SURFACES_2D_COLOR_FORMAT 0x00000300 -#define NV03_CONTEXT_SURFACES_2D_PITCH 0x00000304 -#define NV03_CONTEXT_SURFACES_2D_PITCH_SOURCE_SHIFT 0 -#define NV03_CONTEXT_SURFACES_2D_PITCH_SOURCE_MASK 0x0000ffff -#define NV03_CONTEXT_SURFACES_2D_PITCH_DESTIN_SHIFT 16 -#define NV03_CONTEXT_SURFACES_2D_PITCH_DESTIN_MASK 0xffff0000 -#define NV03_CONTEXT_SURFACES_2D_OFFSET_SOURCE 0x00000308 -#define NV03_CONTEXT_SURFACES_2D_OFFSET_DESTIN 0x0000030c - - -#define NV03_CONTEXT_SURFACES_3D 0x0000005a - -#define NV03_CONTEXT_SURFACES_3D_SYNCHRONIZE 0x00000100 -#define NV03_CONTEXT_SURFACES_3D_DMA_NOTIFY 0x00000180 -#define NV03_CONTEXT_SURFACES_3D_DMA_SURFACE 0x00000184 -#define NV03_CONTEXT_SURFACES_3D_PITCH 0x00000300 -#define NV03_CONTEXT_SURFACES_3D_OFFSET_COLOR 0x00000304 -#define NV03_CONTEXT_SURFACES_3D_OFFSET_ZETA 0x00000308 - - -#define NV04_INDEXED_IMAGE_FROM_CPU 0x00000060 - -#define NV04_INDEXED_IMAGE_FROM_CPU_NOP 0x00000100 -#define NV04_INDEXED_IMAGE_FROM_CPU_NOTIFY 0x00000104 -#define NV04_INDEXED_IMAGE_FROM_CPU_PATCH 0x0000010c -#define NV04_INDEXED_IMAGE_FROM_CPU_DMA_NOTIFY 0x00000180 -#define NV04_INDEXED_IMAGE_FROM_CPU_DMA_LUT 0x00000184 -#define NV04_INDEXED_IMAGE_FROM_CPU_COLOR_KEY 0x00000188 -#define NV04_INDEXED_IMAGE_FROM_CPU_CLIP_RECTANGLE 0x0000018c -#define NV04_INDEXED_IMAGE_FROM_CPU_PATTERN 0x00000190 -#define NV04_INDEXED_IMAGE_FROM_CPU_ROP 0x00000194 -#define NV04_INDEXED_IMAGE_FROM_CPU_BETA1 0x00000198 -#define NV04_INDEXED_IMAGE_FROM_CPU_BETA4 0x0000019c -#define NV04_INDEXED_IMAGE_FROM_CPU_SURFACE 0x000001a0 -#define NV04_INDEXED_IMAGE_FROM_CPU_OPERATION 0x000003e4 -#define NV04_INDEXED_IMAGE_FROM_CPU_COLOR_FORMAT 0x000003e8 -#define NV04_INDEXED_IMAGE_FROM_CPU_INDEX_FORMAT 0x000003ec -#define NV04_INDEXED_IMAGE_FROM_CPU_LUT_OFFSET 0x000003f0 -#define NV04_INDEXED_IMAGE_FROM_CPU_POINT 0x000003f4 -#define NV04_INDEXED_IMAGE_FROM_CPU_SIZE_OUT 0x000003f8 -#define NV04_INDEXED_IMAGE_FROM_CPU_SIZE_IN 0x000003fc -#define NV04_INDEXED_IMAGE_FROM_CPU_COLOR(x) (0x00000400+((x)*4)) -#define NV04_INDEXED_IMAGE_FROM_CPU_COLOR__SIZE 0x00000700 - - -#define NV05_INDEXED_IMAGE_FROM_CPU 0x00000064 - -#define NV05_INDEXED_IMAGE_FROM_CPU_COLOR_CONVERSION 0x000003e0 - - -#define NV03_CHANNEL_PIO 0x0000006a - - - -#define NV03_CHANNEL_DMA 0x0000006b - - - -#define NV04_BETA_SOLID 0x00000072 - -#define NV04_BETA_SOLID_NOP 0x00000100 -#define NV04_BETA_SOLID_NOTIFY 0x00000104 -#define NV04_BETA_SOLID_DMA_NOTIFY 0x00000180 -#define NV04_BETA_SOLID_BETA_OUTPUT 0x00000200 -#define NV04_BETA_SOLID_BETA_FACTOR 0x00000300 - - -#define NV10_TEXTURE_FROM_CPU 0x0000007b - -#define NV10_TEXTURE_FROM_CPU_NOP 0x00000100 -#define NV10_TEXTURE_FROM_CPU_NOTIFY 0x00000104 -#define NV10_TEXTURE_FROM_CPU_WAIT_FOR_IDLE 0x00000108 -#define NV10_TEXTURE_FROM_CPU_PM_TRIGGER 0x00000140 -#define NV10_TEXTURE_FROM_CPU_DMA_NOTIFY 0x00000180 -#define NV10_TEXTURE_FROM_CPU_SURFACE 0x00000184 -#define NV10_TEXTURE_FROM_CPU_COLOR_FORMAT 0x00000300 -#define NV10_TEXTURE_FROM_CPU_POINT 0x00000304 -#define NV10_TEXTURE_FROM_CPU_POINT_X_SHIFT 0 -#define NV10_TEXTURE_FROM_CPU_POINT_X_MASK 0x0000ffff -#define NV10_TEXTURE_FROM_CPU_POINT_Y_SHIFT 16 -#define NV10_TEXTURE_FROM_CPU_POINT_Y_MASK 0xffff0000 -#define NV10_TEXTURE_FROM_CPU_SIZE 0x00000308 -#define NV10_TEXTURE_FROM_CPU_SIZE_W_SHIFT 0 -#define NV10_TEXTURE_FROM_CPU_SIZE_W_MASK 0x0000ffff -#define NV10_TEXTURE_FROM_CPU_SIZE_H_SHIFT 16 -#define NV10_TEXTURE_FROM_CPU_SIZE_H_MASK 0xffff0000 -#define NV10_TEXTURE_FROM_CPU_CLIP_HORIZONTAL 0x0000030c -#define NV10_TEXTURE_FROM_CPU_CLIP_HORIZONTAL_X_SHIFT 0 -#define NV10_TEXTURE_FROM_CPU_CLIP_HORIZONTAL_X_MASK 0x0000ffff -#define NV10_TEXTURE_FROM_CPU_CLIP_HORIZONTAL_W_SHIFT 16 -#define NV10_TEXTURE_FROM_CPU_CLIP_HORIZONTAL_W_MASK 0xffff0000 -#define NV10_TEXTURE_FROM_CPU_CLIP_VERTICAL 0x00000310 -#define NV10_TEXTURE_FROM_CPU_CLIP_VERTICAL_Y_SHIFT 0 -#define NV10_TEXTURE_FROM_CPU_CLIP_VERTICAL_Y_MASK 0x0000ffff -#define NV10_TEXTURE_FROM_CPU_CLIP_VERTICAL_H_SHIFT 16 -#define NV10_TEXTURE_FROM_CPU_CLIP_VERTICAL_H_MASK 0xffff0000 -#define NV10_TEXTURE_FROM_CPU_COLOR(x) (0x00000400+((x)*4)) -#define NV10_TEXTURE_FROM_CPU_COLOR__SIZE 0x00000700 - - -#define NV30_TEXTURE_FROM_CPU 0x0000037b - - - -#define NV40_TEXTURE_FROM_CPU 0x0000307b - - - -#define NV10_VIDEO_DISPLAY 0x0000007c - - - -#define NV20TCL 0x00000097 - -#define NV20TCL_NOP 0x00000100 -#define NV20TCL_NOTIFY 0x00000104 -#define NV20TCL_DMA_NOTIFY 0x00000180 -#define NV20TCL_DMA_TEXTURE0 0x00000184 -#define NV20TCL_DMA_TEXTURE1 0x00000188 -#define NV20TCL_DMA_COLOR 0x00000194 -#define NV20TCL_DMA_ZETA 0x00000198 -#define NV20TCL_DMA_VTXBUF0 0x0000019c -#define NV20TCL_DMA_VTXBUF1 0x000001a0 -#define NV20TCL_DMA_FENCE 0x000001a4 -#define NV20TCL_DMA_QUERY 0x000001a8 -#define NV20TCL_RT_HORIZ 0x00000200 -#define NV20TCL_RT_HORIZ_X_SHIFT 0 -#define NV20TCL_RT_HORIZ_X_MASK 0x0000ffff -#define NV20TCL_RT_HORIZ_W_SHIFT 16 -#define NV20TCL_RT_HORIZ_W_MASK 0xffff0000 -#define NV20TCL_RT_VERT 0x00000204 -#define NV20TCL_RT_VERT_Y_SHIFT 0 -#define NV20TCL_RT_VERT_Y_MASK 0x0000ffff -#define NV20TCL_RT_VERT_H_SHIFT 16 -#define NV20TCL_RT_VERT_H_MASK 0xffff0000 -#define NV20TCL_RT_FORMAT 0x00000208 -#define NV20TCL_RT_FORMAT_TYPE_SHIFT 8 -#define NV20TCL_RT_FORMAT_TYPE_MASK 0x00000f00 -#define NV20TCL_RT_FORMAT_TYPE_LINEAR 0x00000100 -#define NV20TCL_RT_FORMAT_TYPE_SWIZZLED 0x00000200 -#define NV20TCL_RT_FORMAT_COLOR_SHIFT 0 -#define NV20TCL_RT_FORMAT_COLOR_MASK 0x0000001f -#define NV20TCL_RT_FORMAT_COLOR_R5G6B5 0x00000003 -#define NV20TCL_RT_FORMAT_COLOR_X8R8G8B8 0x00000005 -#define NV20TCL_RT_FORMAT_COLOR_A8R8G8B8 0x00000008 -#define NV20TCL_RT_FORMAT_COLOR_B8 0x00000009 -#define NV20TCL_RT_FORMAT_COLOR_UNKNOWN 0x0000000d -#define NV20TCL_RT_FORMAT_COLOR_X8B8G8R8 0x0000000f -#define NV20TCL_RT_FORMAT_COLOR_A8B8G8R8 0x00000010 -#define NV20TCL_RT_PITCH 0x0000020c -#define NV20TCL_RT_PITCH_COLOR_PITCH_SHIFT 0 -#define NV20TCL_RT_PITCH_COLOR_PITCH_MASK 0x0000ffff -#define NV20TCL_RT_PITCH_ZETA_PITCH_SHIFT 16 -#define NV20TCL_RT_PITCH_ZETA_PITCH_MASK 0xffff0000 -#define NV20TCL_COLOR_OFFSET 0x00000210 -#define NV20TCL_ZETA_OFFSET 0x00000214 -#define NV20TCL_RC_IN_ALPHA(x) (0x00000260+((x)*4)) -#define NV20TCL_RC_IN_ALPHA__SIZE 0x00000008 -#define NV20TCL_RC_IN_ALPHA_D_INPUT_SHIFT 0 -#define NV20TCL_RC_IN_ALPHA_D_INPUT_MASK 0x0000000f -#define NV20TCL_RC_IN_ALPHA_D_INPUT_ZERO 0x00000000 -#define NV20TCL_RC_IN_ALPHA_D_INPUT_CONSTANT_COLOR0 0x00000001 -#define NV20TCL_RC_IN_ALPHA_D_INPUT_CONSTANT_COLOR1 0x00000002 -#define NV20TCL_RC_IN_ALPHA_D_INPUT_FOG 0x00000003 -#define NV20TCL_RC_IN_ALPHA_D_INPUT_PRIMARY_COLOR 0x00000004 -#define NV20TCL_RC_IN_ALPHA_D_INPUT_SECONDARY_COLOR 0x00000005 -#define NV20TCL_RC_IN_ALPHA_D_INPUT_TEXTURE0 0x00000008 -#define NV20TCL_RC_IN_ALPHA_D_INPUT_TEXTURE1 0x00000009 -#define NV20TCL_RC_IN_ALPHA_D_INPUT_SPARE0 0x0000000c -#define NV20TCL_RC_IN_ALPHA_D_INPUT_SPARE1 0x0000000d -#define NV20TCL_RC_IN_ALPHA_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e -#define NV20TCL_RC_IN_ALPHA_D_INPUT_E_TIMES_F 0x0000000f -#define NV20TCL_RC_IN_ALPHA_D_INPUT_TEXTURE2 0x0000000a -#define NV20TCL_RC_IN_ALPHA_D_INPUT_TEXTURE3 0x0000000b -#define NV20TCL_RC_IN_ALPHA_D_COMPONENT_USAGE (1 << 4) -#define NV20TCL_RC_IN_ALPHA_D_COMPONENT_USAGE_BLUE 0x00000000 -#define NV20TCL_RC_IN_ALPHA_D_COMPONENT_USAGE_ALPHA 0x00000010 -#define NV20TCL_RC_IN_ALPHA_D_MAPPING_SHIFT 5 -#define NV20TCL_RC_IN_ALPHA_D_MAPPING_MASK 0x000000e0 -#define NV20TCL_RC_IN_ALPHA_D_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV20TCL_RC_IN_ALPHA_D_MAPPING_UNSIGNED_INVERT 0x00000020 -#define NV20TCL_RC_IN_ALPHA_D_MAPPING_EXPAND_NORMAL 0x00000040 -#define NV20TCL_RC_IN_ALPHA_D_MAPPING_EXPAND_NEGATE 0x00000060 -#define NV20TCL_RC_IN_ALPHA_D_MAPPING_HALF_BIAS_NORMAL 0x00000080 -#define NV20TCL_RC_IN_ALPHA_D_MAPPING_HALF_BIAS_NEGATE 0x000000a0 -#define NV20TCL_RC_IN_ALPHA_D_MAPPING_SIGNED_IDENTITY 0x000000c0 -#define NV20TCL_RC_IN_ALPHA_D_MAPPING_SIGNED_NEGATE 0x000000e0 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_SHIFT 8 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_MASK 0x00000f00 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_ZERO 0x00000000 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_CONSTANT_COLOR0 0x00000100 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_CONSTANT_COLOR1 0x00000200 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_FOG 0x00000300 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_PRIMARY_COLOR 0x00000400 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_SECONDARY_COLOR 0x00000500 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_TEXTURE0 0x00000800 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_TEXTURE1 0x00000900 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_SPARE0 0x00000c00 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_SPARE1 0x00000d00 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_E_TIMES_F 0x00000f00 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_TEXTURE2 0x00000a00 -#define NV20TCL_RC_IN_ALPHA_C_INPUT_TEXTURE3 0x00000b00 -#define NV20TCL_RC_IN_ALPHA_C_COMPONENT_USAGE (1 << 12) -#define NV20TCL_RC_IN_ALPHA_C_COMPONENT_USAGE_BLUE 0x00000000 -#define NV20TCL_RC_IN_ALPHA_C_COMPONENT_USAGE_ALPHA 0x00001000 -#define NV20TCL_RC_IN_ALPHA_C_MAPPING_SHIFT 13 -#define NV20TCL_RC_IN_ALPHA_C_MAPPING_MASK 0x0000e000 -#define NV20TCL_RC_IN_ALPHA_C_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV20TCL_RC_IN_ALPHA_C_MAPPING_UNSIGNED_INVERT 0x00002000 -#define NV20TCL_RC_IN_ALPHA_C_MAPPING_EXPAND_NORMAL 0x00004000 -#define NV20TCL_RC_IN_ALPHA_C_MAPPING_EXPAND_NEGATE 0x00006000 -#define NV20TCL_RC_IN_ALPHA_C_MAPPING_HALF_BIAS_NORMAL 0x00008000 -#define NV20TCL_RC_IN_ALPHA_C_MAPPING_HALF_BIAS_NEGATE 0x0000a000 -#define NV20TCL_RC_IN_ALPHA_C_MAPPING_SIGNED_IDENTITY 0x0000c000 -#define NV20TCL_RC_IN_ALPHA_C_MAPPING_SIGNED_NEGATE 0x0000e000 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_SHIFT 16 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_MASK 0x000f0000 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_ZERO 0x00000000 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_CONSTANT_COLOR0 0x00010000 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_CONSTANT_COLOR1 0x00020000 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_FOG 0x00030000 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_PRIMARY_COLOR 0x00040000 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_SECONDARY_COLOR 0x00050000 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_TEXTURE0 0x00080000 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_TEXTURE1 0x00090000 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_SPARE0 0x000c0000 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_SPARE1 0x000d0000 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_E_TIMES_F 0x000f0000 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_TEXTURE2 0x000a0000 -#define NV20TCL_RC_IN_ALPHA_B_INPUT_TEXTURE3 0x000b0000 -#define NV20TCL_RC_IN_ALPHA_B_COMPONENT_USAGE (1 << 20) -#define NV20TCL_RC_IN_ALPHA_B_COMPONENT_USAGE_BLUE 0x00000000 -#define NV20TCL_RC_IN_ALPHA_B_COMPONENT_USAGE_ALPHA 0x00100000 -#define NV20TCL_RC_IN_ALPHA_B_MAPPING_SHIFT 21 -#define NV20TCL_RC_IN_ALPHA_B_MAPPING_MASK 0x00e00000 -#define NV20TCL_RC_IN_ALPHA_B_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV20TCL_RC_IN_ALPHA_B_MAPPING_UNSIGNED_INVERT 0x00200000 -#define NV20TCL_RC_IN_ALPHA_B_MAPPING_EXPAND_NORMAL 0x00400000 -#define NV20TCL_RC_IN_ALPHA_B_MAPPING_EXPAND_NEGATE 0x00600000 -#define NV20TCL_RC_IN_ALPHA_B_MAPPING_HALF_BIAS_NORMAL 0x00800000 -#define NV20TCL_RC_IN_ALPHA_B_MAPPING_HALF_BIAS_NEGATE 0x00a00000 -#define NV20TCL_RC_IN_ALPHA_B_MAPPING_SIGNED_IDENTITY 0x00c00000 -#define NV20TCL_RC_IN_ALPHA_B_MAPPING_SIGNED_NEGATE 0x00e00000 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_SHIFT 24 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_MASK 0x0f000000 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_ZERO 0x00000000 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_CONSTANT_COLOR0 0x01000000 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_CONSTANT_COLOR1 0x02000000 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_FOG 0x03000000 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_PRIMARY_COLOR 0x04000000 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_SECONDARY_COLOR 0x05000000 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_TEXTURE0 0x08000000 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_TEXTURE1 0x09000000 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_SPARE0 0x0c000000 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_SPARE1 0x0d000000 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_E_TIMES_F 0x0f000000 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_TEXTURE2 0x0a000000 -#define NV20TCL_RC_IN_ALPHA_A_INPUT_TEXTURE3 0x0b000000 -#define NV20TCL_RC_IN_ALPHA_A_COMPONENT_USAGE (1 << 28) -#define NV20TCL_RC_IN_ALPHA_A_COMPONENT_USAGE_BLUE 0x00000000 -#define NV20TCL_RC_IN_ALPHA_A_COMPONENT_USAGE_ALPHA 0x10000000 -#define NV20TCL_RC_IN_ALPHA_A_MAPPING_SHIFT 29 -#define NV20TCL_RC_IN_ALPHA_A_MAPPING_MASK 0xe0000000 -#define NV20TCL_RC_IN_ALPHA_A_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV20TCL_RC_IN_ALPHA_A_MAPPING_UNSIGNED_INVERT 0x20000000 -#define NV20TCL_RC_IN_ALPHA_A_MAPPING_EXPAND_NORMAL 0x40000000 -#define NV20TCL_RC_IN_ALPHA_A_MAPPING_EXPAND_NEGATE 0x60000000 -#define NV20TCL_RC_IN_ALPHA_A_MAPPING_HALF_BIAS_NORMAL 0x80000000 -#define NV20TCL_RC_IN_ALPHA_A_MAPPING_HALF_BIAS_NEGATE 0xa0000000 -#define NV20TCL_RC_IN_ALPHA_A_MAPPING_SIGNED_IDENTITY 0xc0000000 -#define NV20TCL_RC_IN_ALPHA_A_MAPPING_SIGNED_NEGATE 0xe0000000 -#define NV20TCL_RC_FINAL0 0x00000288 -#define NV20TCL_RC_FINAL0_D_INPUT_SHIFT 0 -#define NV20TCL_RC_FINAL0_D_INPUT_MASK 0x0000000f -#define NV20TCL_RC_FINAL0_D_INPUT_ZERO 0x00000000 -#define NV20TCL_RC_FINAL0_D_INPUT_CONSTANT_COLOR0 0x00000001 -#define NV20TCL_RC_FINAL0_D_INPUT_CONSTANT_COLOR1 0x00000002 -#define NV20TCL_RC_FINAL0_D_INPUT_FOG 0x00000003 -#define NV20TCL_RC_FINAL0_D_INPUT_PRIMARY_COLOR 0x00000004 -#define NV20TCL_RC_FINAL0_D_INPUT_SECONDARY_COLOR 0x00000005 -#define NV20TCL_RC_FINAL0_D_INPUT_TEXTURE0 0x00000008 -#define NV20TCL_RC_FINAL0_D_INPUT_TEXTURE1 0x00000009 -#define NV20TCL_RC_FINAL0_D_INPUT_SPARE0 0x0000000c -#define NV20TCL_RC_FINAL0_D_INPUT_SPARE1 0x0000000d -#define NV20TCL_RC_FINAL0_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e -#define NV20TCL_RC_FINAL0_D_INPUT_E_TIMES_F 0x0000000f -#define NV20TCL_RC_FINAL0_D_INPUT_TEXTURE2 0x0000000a -#define NV20TCL_RC_FINAL0_D_INPUT_TEXTURE3 0x0000000b -#define NV20TCL_RC_FINAL0_D_COMPONENT_USAGE (1 << 4) -#define NV20TCL_RC_FINAL0_D_COMPONENT_USAGE_RGB 0x00000000 -#define NV20TCL_RC_FINAL0_D_COMPONENT_USAGE_ALPHA 0x00000010 -#define NV20TCL_RC_FINAL0_D_MAPPING_SHIFT 5 -#define NV20TCL_RC_FINAL0_D_MAPPING_MASK 0x000000e0 -#define NV20TCL_RC_FINAL0_D_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV20TCL_RC_FINAL0_D_MAPPING_UNSIGNED_INVERT 0x00000020 -#define NV20TCL_RC_FINAL0_D_MAPPING_EXPAND_NORMAL 0x00000040 -#define NV20TCL_RC_FINAL0_D_MAPPING_EXPAND_NEGATE 0x00000060 -#define NV20TCL_RC_FINAL0_D_MAPPING_HALF_BIAS_NORMAL 0x00000080 -#define NV20TCL_RC_FINAL0_D_MAPPING_HALF_BIAS_NEGATE 0x000000a0 -#define NV20TCL_RC_FINAL0_D_MAPPING_SIGNED_IDENTITY 0x000000c0 -#define NV20TCL_RC_FINAL0_D_MAPPING_SIGNED_NEGATE 0x000000e0 -#define NV20TCL_RC_FINAL0_C_INPUT_SHIFT 8 -#define NV20TCL_RC_FINAL0_C_INPUT_MASK 0x00000f00 -#define NV20TCL_RC_FINAL0_C_INPUT_ZERO 0x00000000 -#define NV20TCL_RC_FINAL0_C_INPUT_CONSTANT_COLOR0 0x00000100 -#define NV20TCL_RC_FINAL0_C_INPUT_CONSTANT_COLOR1 0x00000200 -#define NV20TCL_RC_FINAL0_C_INPUT_FOG 0x00000300 -#define NV20TCL_RC_FINAL0_C_INPUT_PRIMARY_COLOR 0x00000400 -#define NV20TCL_RC_FINAL0_C_INPUT_SECONDARY_COLOR 0x00000500 -#define NV20TCL_RC_FINAL0_C_INPUT_TEXTURE0 0x00000800 -#define NV20TCL_RC_FINAL0_C_INPUT_TEXTURE1 0x00000900 -#define NV20TCL_RC_FINAL0_C_INPUT_SPARE0 0x00000c00 -#define NV20TCL_RC_FINAL0_C_INPUT_SPARE1 0x00000d00 -#define NV20TCL_RC_FINAL0_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 -#define NV20TCL_RC_FINAL0_C_INPUT_E_TIMES_F 0x00000f00 -#define NV20TCL_RC_FINAL0_C_INPUT_TEXTURE2 0x00000a00 -#define NV20TCL_RC_FINAL0_C_INPUT_TEXTURE3 0x00000b00 -#define NV20TCL_RC_FINAL0_C_COMPONENT_USAGE (1 << 12) -#define NV20TCL_RC_FINAL0_C_COMPONENT_USAGE_RGB 0x00000000 -#define NV20TCL_RC_FINAL0_C_COMPONENT_USAGE_ALPHA 0x00001000 -#define NV20TCL_RC_FINAL0_C_MAPPING_SHIFT 13 -#define NV20TCL_RC_FINAL0_C_MAPPING_MASK 0x0000e000 -#define NV20TCL_RC_FINAL0_C_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV20TCL_RC_FINAL0_C_MAPPING_UNSIGNED_INVERT 0x00002000 -#define NV20TCL_RC_FINAL0_C_MAPPING_EXPAND_NORMAL 0x00004000 -#define NV20TCL_RC_FINAL0_C_MAPPING_EXPAND_NEGATE 0x00006000 -#define NV20TCL_RC_FINAL0_C_MAPPING_HALF_BIAS_NORMAL 0x00008000 -#define NV20TCL_RC_FINAL0_C_MAPPING_HALF_BIAS_NEGATE 0x0000a000 -#define NV20TCL_RC_FINAL0_C_MAPPING_SIGNED_IDENTITY 0x0000c000 -#define NV20TCL_RC_FINAL0_C_MAPPING_SIGNED_NEGATE 0x0000e000 -#define NV20TCL_RC_FINAL0_B_INPUT_SHIFT 16 -#define NV20TCL_RC_FINAL0_B_INPUT_MASK 0x000f0000 -#define NV20TCL_RC_FINAL0_B_INPUT_ZERO 0x00000000 -#define NV20TCL_RC_FINAL0_B_INPUT_CONSTANT_COLOR0 0x00010000 -#define NV20TCL_RC_FINAL0_B_INPUT_CONSTANT_COLOR1 0x00020000 -#define NV20TCL_RC_FINAL0_B_INPUT_FOG 0x00030000 -#define NV20TCL_RC_FINAL0_B_INPUT_PRIMARY_COLOR 0x00040000 -#define NV20TCL_RC_FINAL0_B_INPUT_SECONDARY_COLOR 0x00050000 -#define NV20TCL_RC_FINAL0_B_INPUT_TEXTURE0 0x00080000 -#define NV20TCL_RC_FINAL0_B_INPUT_TEXTURE1 0x00090000 -#define NV20TCL_RC_FINAL0_B_INPUT_SPARE0 0x000c0000 -#define NV20TCL_RC_FINAL0_B_INPUT_SPARE1 0x000d0000 -#define NV20TCL_RC_FINAL0_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 -#define NV20TCL_RC_FINAL0_B_INPUT_E_TIMES_F 0x000f0000 -#define NV20TCL_RC_FINAL0_B_INPUT_TEXTURE2 0x000a0000 -#define NV20TCL_RC_FINAL0_B_INPUT_TEXTURE3 0x000b0000 -#define NV20TCL_RC_FINAL0_B_COMPONENT_USAGE (1 << 20) -#define NV20TCL_RC_FINAL0_B_COMPONENT_USAGE_RGB 0x00000000 -#define NV20TCL_RC_FINAL0_B_COMPONENT_USAGE_ALPHA 0x00100000 -#define NV20TCL_RC_FINAL0_B_MAPPING_SHIFT 21 -#define NV20TCL_RC_FINAL0_B_MAPPING_MASK 0x00e00000 -#define NV20TCL_RC_FINAL0_B_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV20TCL_RC_FINAL0_B_MAPPING_UNSIGNED_INVERT 0x00200000 -#define NV20TCL_RC_FINAL0_B_MAPPING_EXPAND_NORMAL 0x00400000 -#define NV20TCL_RC_FINAL0_B_MAPPING_EXPAND_NEGATE 0x00600000 -#define NV20TCL_RC_FINAL0_B_MAPPING_HALF_BIAS_NORMAL 0x00800000 -#define NV20TCL_RC_FINAL0_B_MAPPING_HALF_BIAS_NEGATE 0x00a00000 -#define NV20TCL_RC_FINAL0_B_MAPPING_SIGNED_IDENTITY 0x00c00000 -#define NV20TCL_RC_FINAL0_B_MAPPING_SIGNED_NEGATE 0x00e00000 -#define NV20TCL_RC_FINAL0_A_INPUT_SHIFT 24 -#define NV20TCL_RC_FINAL0_A_INPUT_MASK 0x0f000000 -#define NV20TCL_RC_FINAL0_A_INPUT_ZERO 0x00000000 -#define NV20TCL_RC_FINAL0_A_INPUT_CONSTANT_COLOR0 0x01000000 -#define NV20TCL_RC_FINAL0_A_INPUT_CONSTANT_COLOR1 0x02000000 -#define NV20TCL_RC_FINAL0_A_INPUT_FOG 0x03000000 -#define NV20TCL_RC_FINAL0_A_INPUT_PRIMARY_COLOR 0x04000000 -#define NV20TCL_RC_FINAL0_A_INPUT_SECONDARY_COLOR 0x05000000 -#define NV20TCL_RC_FINAL0_A_INPUT_TEXTURE0 0x08000000 -#define NV20TCL_RC_FINAL0_A_INPUT_TEXTURE1 0x09000000 -#define NV20TCL_RC_FINAL0_A_INPUT_SPARE0 0x0c000000 -#define NV20TCL_RC_FINAL0_A_INPUT_SPARE1 0x0d000000 -#define NV20TCL_RC_FINAL0_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 -#define NV20TCL_RC_FINAL0_A_INPUT_E_TIMES_F 0x0f000000 -#define NV20TCL_RC_FINAL0_A_INPUT_TEXTURE2 0x0a000000 -#define NV20TCL_RC_FINAL0_A_INPUT_TEXTURE3 0x0b000000 -#define NV20TCL_RC_FINAL0_A_COMPONENT_USAGE (1 << 28) -#define NV20TCL_RC_FINAL0_A_COMPONENT_USAGE_RGB 0x00000000 -#define NV20TCL_RC_FINAL0_A_COMPONENT_USAGE_ALPHA 0x10000000 -#define NV20TCL_RC_FINAL0_A_MAPPING_SHIFT 29 -#define NV20TCL_RC_FINAL0_A_MAPPING_MASK 0xe0000000 -#define NV20TCL_RC_FINAL0_A_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV20TCL_RC_FINAL0_A_MAPPING_UNSIGNED_INVERT 0x20000000 -#define NV20TCL_RC_FINAL0_A_MAPPING_EXPAND_NORMAL 0x40000000 -#define NV20TCL_RC_FINAL0_A_MAPPING_EXPAND_NEGATE 0x60000000 -#define NV20TCL_RC_FINAL0_A_MAPPING_HALF_BIAS_NORMAL 0x80000000 -#define NV20TCL_RC_FINAL0_A_MAPPING_HALF_BIAS_NEGATE 0xa0000000 -#define NV20TCL_RC_FINAL0_A_MAPPING_SIGNED_IDENTITY 0xc0000000 -#define NV20TCL_RC_FINAL0_A_MAPPING_SIGNED_NEGATE 0xe0000000 -#define NV20TCL_RC_FINAL1 0x0000028c -#define NV20TCL_RC_FINAL1_COLOR_SUM_CLAMP (1 << 7) -#define NV20TCL_RC_FINAL1_G_INPUT_SHIFT 8 -#define NV20TCL_RC_FINAL1_G_INPUT_MASK 0x00000f00 -#define NV20TCL_RC_FINAL1_G_INPUT_ZERO 0x00000000 -#define NV20TCL_RC_FINAL1_G_INPUT_CONSTANT_COLOR0 0x00000100 -#define NV20TCL_RC_FINAL1_G_INPUT_CONSTANT_COLOR1 0x00000200 -#define NV20TCL_RC_FINAL1_G_INPUT_FOG 0x00000300 -#define NV20TCL_RC_FINAL1_G_INPUT_PRIMARY_COLOR 0x00000400 -#define NV20TCL_RC_FINAL1_G_INPUT_SECONDARY_COLOR 0x00000500 -#define NV20TCL_RC_FINAL1_G_INPUT_TEXTURE0 0x00000800 -#define NV20TCL_RC_FINAL1_G_INPUT_TEXTURE1 0x00000900 -#define NV20TCL_RC_FINAL1_G_INPUT_SPARE0 0x00000c00 -#define NV20TCL_RC_FINAL1_G_INPUT_SPARE1 0x00000d00 -#define NV20TCL_RC_FINAL1_G_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 -#define NV20TCL_RC_FINAL1_G_INPUT_E_TIMES_F 0x00000f00 -#define NV20TCL_RC_FINAL1_G_INPUT_TEXTURE2 0x00000a00 -#define NV20TCL_RC_FINAL1_G_INPUT_TEXTURE3 0x00000b00 -#define NV20TCL_RC_FINAL1_G_COMPONENT_USAGE (1 << 12) -#define NV20TCL_RC_FINAL1_G_COMPONENT_USAGE_RGB 0x00000000 -#define NV20TCL_RC_FINAL1_G_COMPONENT_USAGE_ALPHA 0x00001000 -#define NV20TCL_RC_FINAL1_G_MAPPING_SHIFT 13 -#define NV20TCL_RC_FINAL1_G_MAPPING_MASK 0x0000e000 -#define NV20TCL_RC_FINAL1_G_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV20TCL_RC_FINAL1_G_MAPPING_UNSIGNED_INVERT 0x00002000 -#define NV20TCL_RC_FINAL1_G_MAPPING_EXPAND_NORMAL 0x00004000 -#define NV20TCL_RC_FINAL1_G_MAPPING_EXPAND_NEGATE 0x00006000 -#define NV20TCL_RC_FINAL1_G_MAPPING_HALF_BIAS_NORMAL 0x00008000 -#define NV20TCL_RC_FINAL1_G_MAPPING_HALF_BIAS_NEGATE 0x0000a000 -#define NV20TCL_RC_FINAL1_G_MAPPING_SIGNED_IDENTITY 0x0000c000 -#define NV20TCL_RC_FINAL1_G_MAPPING_SIGNED_NEGATE 0x0000e000 -#define NV20TCL_RC_FINAL1_F_INPUT_SHIFT 16 -#define NV20TCL_RC_FINAL1_F_INPUT_MASK 0x000f0000 -#define NV20TCL_RC_FINAL1_F_INPUT_ZERO 0x00000000 -#define NV20TCL_RC_FINAL1_F_INPUT_CONSTANT_COLOR0 0x00010000 -#define NV20TCL_RC_FINAL1_F_INPUT_CONSTANT_COLOR1 0x00020000 -#define NV20TCL_RC_FINAL1_F_INPUT_FOG 0x00030000 -#define NV20TCL_RC_FINAL1_F_INPUT_PRIMARY_COLOR 0x00040000 -#define NV20TCL_RC_FINAL1_F_INPUT_SECONDARY_COLOR 0x00050000 -#define NV20TCL_RC_FINAL1_F_INPUT_TEXTURE0 0x00080000 -#define NV20TCL_RC_FINAL1_F_INPUT_TEXTURE1 0x00090000 -#define NV20TCL_RC_FINAL1_F_INPUT_SPARE0 0x000c0000 -#define NV20TCL_RC_FINAL1_F_INPUT_SPARE1 0x000d0000 -#define NV20TCL_RC_FINAL1_F_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 -#define NV20TCL_RC_FINAL1_F_INPUT_E_TIMES_F 0x000f0000 -#define NV20TCL_RC_FINAL1_F_INPUT_TEXTURE2 0x000a0000 -#define NV20TCL_RC_FINAL1_F_INPUT_TEXTURE3 0x000b0000 -#define NV20TCL_RC_FINAL1_F_COMPONENT_USAGE (1 << 20) -#define NV20TCL_RC_FINAL1_F_COMPONENT_USAGE_RGB 0x00000000 -#define NV20TCL_RC_FINAL1_F_COMPONENT_USAGE_ALPHA 0x00100000 -#define NV20TCL_RC_FINAL1_F_MAPPING_SHIFT 21 -#define NV20TCL_RC_FINAL1_F_MAPPING_MASK 0x00e00000 -#define NV20TCL_RC_FINAL1_F_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV20TCL_RC_FINAL1_F_MAPPING_UNSIGNED_INVERT 0x00200000 -#define NV20TCL_RC_FINAL1_F_MAPPING_EXPAND_NORMAL 0x00400000 -#define NV20TCL_RC_FINAL1_F_MAPPING_EXPAND_NEGATE 0x00600000 -#define NV20TCL_RC_FINAL1_F_MAPPING_HALF_BIAS_NORMAL 0x00800000 -#define NV20TCL_RC_FINAL1_F_MAPPING_HALF_BIAS_NEGATE 0x00a00000 -#define NV20TCL_RC_FINAL1_F_MAPPING_SIGNED_IDENTITY 0x00c00000 -#define NV20TCL_RC_FINAL1_F_MAPPING_SIGNED_NEGATE 0x00e00000 -#define NV20TCL_RC_FINAL1_E_INPUT_SHIFT 24 -#define NV20TCL_RC_FINAL1_E_INPUT_MASK 0x0f000000 -#define NV20TCL_RC_FINAL1_E_INPUT_ZERO 0x00000000 -#define NV20TCL_RC_FINAL1_E_INPUT_CONSTANT_COLOR0 0x01000000 -#define NV20TCL_RC_FINAL1_E_INPUT_CONSTANT_COLOR1 0x02000000 -#define NV20TCL_RC_FINAL1_E_INPUT_FOG 0x03000000 -#define NV20TCL_RC_FINAL1_E_INPUT_PRIMARY_COLOR 0x04000000 -#define NV20TCL_RC_FINAL1_E_INPUT_SECONDARY_COLOR 0x05000000 -#define NV20TCL_RC_FINAL1_E_INPUT_TEXTURE0 0x08000000 -#define NV20TCL_RC_FINAL1_E_INPUT_TEXTURE1 0x09000000 -#define NV20TCL_RC_FINAL1_E_INPUT_SPARE0 0x0c000000 -#define NV20TCL_RC_FINAL1_E_INPUT_SPARE1 0x0d000000 -#define NV20TCL_RC_FINAL1_E_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 -#define NV20TCL_RC_FINAL1_E_INPUT_E_TIMES_F 0x0f000000 -#define NV20TCL_RC_FINAL1_E_INPUT_TEXTURE2 0x0a000000 -#define NV20TCL_RC_FINAL1_E_INPUT_TEXTURE3 0x0b000000 -#define NV20TCL_RC_FINAL1_E_COMPONENT_USAGE (1 << 28) -#define NV20TCL_RC_FINAL1_E_COMPONENT_USAGE_RGB 0x00000000 -#define NV20TCL_RC_FINAL1_E_COMPONENT_USAGE_ALPHA 0x10000000 -#define NV20TCL_RC_FINAL1_E_MAPPING_SHIFT 29 -#define NV20TCL_RC_FINAL1_E_MAPPING_MASK 0xe0000000 -#define NV20TCL_RC_FINAL1_E_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV20TCL_RC_FINAL1_E_MAPPING_UNSIGNED_INVERT 0x20000000 -#define NV20TCL_RC_FINAL1_E_MAPPING_EXPAND_NORMAL 0x40000000 -#define NV20TCL_RC_FINAL1_E_MAPPING_EXPAND_NEGATE 0x60000000 -#define NV20TCL_RC_FINAL1_E_MAPPING_HALF_BIAS_NORMAL 0x80000000 -#define NV20TCL_RC_FINAL1_E_MAPPING_HALF_BIAS_NEGATE 0xa0000000 -#define NV20TCL_RC_FINAL1_E_MAPPING_SIGNED_IDENTITY 0xc0000000 -#define NV20TCL_RC_FINAL1_E_MAPPING_SIGNED_NEGATE 0xe0000000 -#define NV20TCL_LIGHT_MODEL 0x00000294 -#define NV20TCL_LIGHT_MODEL_VIEWER_SHIFT 16 -#define NV20TCL_LIGHT_MODEL_VIEWER_MASK 0x00030000 -#define NV20TCL_LIGHT_MODEL_VIEWER_NONLOCAL 0x00020000 -#define NV20TCL_LIGHT_MODEL_VIEWER_LOCAL 0x00030000 -#define NV20TCL_LIGHT_MODEL_SEPARATE_SPECULAR (1 << 0) -#define NV20TCL_COLOR_MATERIAL 0x00000298 -#define NV20TCL_COLOR_MATERIAL_FRONT_EMISSION_SHIFT 0 -#define NV20TCL_COLOR_MATERIAL_FRONT_EMISSION_MASK 0x00000003 -#define NV20TCL_COLOR_MATERIAL_FRONT_EMISSION_OFF 0x00000000 -#define NV20TCL_COLOR_MATERIAL_FRONT_EMISSION_COL1 0x00000001 -#define NV20TCL_COLOR_MATERIAL_FRONT_EMISSION_COL2 0x00000002 -#define NV20TCL_COLOR_MATERIAL_FRONT_AMBIENT_SHIFT 2 -#define NV20TCL_COLOR_MATERIAL_FRONT_AMBIENT_MASK 0x0000000c -#define NV20TCL_COLOR_MATERIAL_FRONT_AMBIENT_OFF 0x00000000 -#define NV20TCL_COLOR_MATERIAL_FRONT_AMBIENT_COL1 0x00000004 -#define NV20TCL_COLOR_MATERIAL_FRONT_AMBIENT_COL2 0x00000008 -#define NV20TCL_COLOR_MATERIAL_FRONT_DIFFUSE_SHIFT 4 -#define NV20TCL_COLOR_MATERIAL_FRONT_DIFFUSE_MASK 0x00000030 -#define NV20TCL_COLOR_MATERIAL_FRONT_DIFFUSE_OFF 0x00000000 -#define NV20TCL_COLOR_MATERIAL_FRONT_DIFFUSE_COL1 0x00000010 -#define NV20TCL_COLOR_MATERIAL_FRONT_DIFFUSE_COL2 0x00000020 -#define NV20TCL_COLOR_MATERIAL_FRONT_SPECULAR_SHIFT 6 -#define NV20TCL_COLOR_MATERIAL_FRONT_SPECULAR_MASK 0x000000c0 -#define NV20TCL_COLOR_MATERIAL_FRONT_SPECULAR_OFF 0x00000000 -#define NV20TCL_COLOR_MATERIAL_FRONT_SPECULAR_COL1 0x00000040 -#define NV20TCL_COLOR_MATERIAL_FRONT_SPECULAR_COL2 0x00000080 -#define NV20TCL_COLOR_MATERIAL_BACK_EMISSION_SHIFT 8 -#define NV20TCL_COLOR_MATERIAL_BACK_EMISSION_MASK 0x00000300 -#define NV20TCL_COLOR_MATERIAL_BACK_EMISSION_OFF 0x00000000 -#define NV20TCL_COLOR_MATERIAL_BACK_EMISSION_COL1 0x00000100 -#define NV20TCL_COLOR_MATERIAL_BACK_EMISSION_COL2 0x00000200 -#define NV20TCL_COLOR_MATERIAL_BACK_AMBIENT_SHIFT 10 -#define NV20TCL_COLOR_MATERIAL_BACK_AMBIENT_MASK 0x00000c00 -#define NV20TCL_COLOR_MATERIAL_BACK_AMBIENT_OFF 0x00000000 -#define NV20TCL_COLOR_MATERIAL_BACK_AMBIENT_COL1 0x00000400 -#define NV20TCL_COLOR_MATERIAL_BACK_AMBIENT_COL2 0x00000800 -#define NV20TCL_COLOR_MATERIAL_BACK_DIFFUSE_SHIFT 12 -#define NV20TCL_COLOR_MATERIAL_BACK_DIFFUSE_MASK 0x00003000 -#define NV20TCL_COLOR_MATERIAL_BACK_DIFFUSE_OFF 0x00000000 -#define NV20TCL_COLOR_MATERIAL_BACK_DIFFUSE_COL1 0x00001000 -#define NV20TCL_COLOR_MATERIAL_BACK_DIFFUSE_COL2 0x00002000 -#define NV20TCL_COLOR_MATERIAL_BACK_SPECULAR_SHIFT 14 -#define NV20TCL_COLOR_MATERIAL_BACK_SPECULAR_MASK 0x0000c000 -#define NV20TCL_COLOR_MATERIAL_BACK_SPECULAR_OFF 0x00000000 -#define NV20TCL_COLOR_MATERIAL_BACK_SPECULAR_COL1 0x00004000 -#define NV20TCL_COLOR_MATERIAL_BACK_SPECULAR_COL2 0x00008000 -#define NV20TCL_FOG_MODE 0x0000029c -#define NV20TCL_FOG_MODE_LINEAR_UNSIGNED 0x00000804 -#define NV20TCL_FOG_MODE_LINEAR_SIGNED 0x00002601 -#define NV20TCL_FOG_MODE_EXP_UNSIGNED 0x00000802 -#define NV20TCL_FOG_MODE_EXP_SIGNED 0x00000800 -#define NV20TCL_FOG_MODE_EXP2_UNSIGNED 0x00000803 -#define NV20TCL_FOG_MODE_EXP2_SIGNED 0x00000801 -#define NV20TCL_FOG_COORD 0x000002a0 -#define NV20TCL_FOG_COORD_DIST_RADIAL 0x00000001 -#define NV20TCL_FOG_COORD_DIST_ORTHOGONAL 0x00000002 -#define NV20TCL_FOG_COORD_DIST_ORTHOGONAL_ABS 0x00000003 -#define NV20TCL_FOG_COORD_FOG 0x00000006 -#define NV20TCL_FOG_ENABLE 0x000002a4 -#define NV20TCL_FOG_COLOR 0x000002a8 -#define NV20TCL_FOG_COLOR_R_SHIFT 0 -#define NV20TCL_FOG_COLOR_R_MASK 0x000000ff -#define NV20TCL_FOG_COLOR_G_SHIFT 8 -#define NV20TCL_FOG_COLOR_G_MASK 0x0000ff00 -#define NV20TCL_FOG_COLOR_B_SHIFT 16 -#define NV20TCL_FOG_COLOR_B_MASK 0x00ff0000 -#define NV20TCL_FOG_COLOR_A_SHIFT 24 -#define NV20TCL_FOG_COLOR_A_MASK 0xff000000 -#define NV20TCL_VIEWPORT_CLIP_MODE 0x000002b4 -#define NV20TCL_VIEWPORT_CLIP_HORIZ(x) (0x000002c0+((x)*4)) -#define NV20TCL_VIEWPORT_CLIP_HORIZ__SIZE 0x00000008 -#define NV20TCL_VIEWPORT_CLIP_VERT(x) (0x000002e0+((x)*4)) -#define NV20TCL_VIEWPORT_CLIP_VERT__SIZE 0x00000008 -#define NV20TCL_ALPHA_FUNC_ENABLE 0x00000300 -#define NV20TCL_BLEND_FUNC_ENABLE 0x00000304 -#define NV20TCL_CULL_FACE_ENABLE 0x00000308 -#define NV20TCL_DEPTH_TEST_ENABLE 0x0000030c -#define NV20TCL_DITHER_ENABLE 0x00000310 -#define NV20TCL_LIGHTING_ENABLE 0x00000314 -#define NV20TCL_POINT_PARAMETERS_ENABLE 0x00000318 -#define NV20TCL_POINT_SMOOTH_ENABLE 0x0000031c -#define NV20TCL_LINE_SMOOTH_ENABLE 0x00000320 -#define NV20TCL_POLYGON_SMOOTH_ENABLE 0x00000324 -#define NV20TCL_STENCIL_ENABLE 0x0000032c -#define NV20TCL_POLYGON_OFFSET_POINT_ENABLE 0x00000330 -#define NV20TCL_POLYGON_OFFSET_LINE_ENABLE 0x00000334 -#define NV20TCL_POLYGON_OFFSET_FILL_ENABLE 0x00000338 -#define NV20TCL_ALPHA_FUNC_FUNC 0x0000033c -#define NV20TCL_ALPHA_FUNC_FUNC_NEVER 0x00000200 -#define NV20TCL_ALPHA_FUNC_FUNC_LESS 0x00000201 -#define NV20TCL_ALPHA_FUNC_FUNC_EQUAL 0x00000202 -#define NV20TCL_ALPHA_FUNC_FUNC_LEQUAL 0x00000203 -#define NV20TCL_ALPHA_FUNC_FUNC_GREATER 0x00000204 -#define NV20TCL_ALPHA_FUNC_FUNC_NOTEQUAL 0x00000205 -#define NV20TCL_ALPHA_FUNC_FUNC_GEQUAL 0x00000206 -#define NV20TCL_ALPHA_FUNC_FUNC_ALWAYS 0x00000207 -#define NV20TCL_ALPHA_FUNC_REF 0x00000340 -#define NV20TCL_BLEND_FUNC_SRC 0x00000344 -#define NV20TCL_BLEND_FUNC_SRC_ZERO 0x00000000 -#define NV20TCL_BLEND_FUNC_SRC_ONE 0x00000001 -#define NV20TCL_BLEND_FUNC_SRC_SRC_COLOR 0x00000300 -#define NV20TCL_BLEND_FUNC_SRC_ONE_MINUS_SRC_COLOR 0x00000301 -#define NV20TCL_BLEND_FUNC_SRC_SRC_ALPHA 0x00000302 -#define NV20TCL_BLEND_FUNC_SRC_ONE_MINUS_SRC_ALPHA 0x00000303 -#define NV20TCL_BLEND_FUNC_SRC_DST_ALPHA 0x00000304 -#define NV20TCL_BLEND_FUNC_SRC_ONE_MINUS_DST_ALPHA 0x00000305 -#define NV20TCL_BLEND_FUNC_SRC_DST_COLOR 0x00000306 -#define NV20TCL_BLEND_FUNC_SRC_ONE_MINUS_DST_COLOR 0x00000307 -#define NV20TCL_BLEND_FUNC_SRC_SRC_ALPHA_SATURATE 0x00000308 -#define NV20TCL_BLEND_FUNC_SRC_CONSTANT_COLOR 0x00008001 -#define NV20TCL_BLEND_FUNC_SRC_ONE_MINUS_CONSTANT_COLOR 0x00008002 -#define NV20TCL_BLEND_FUNC_SRC_CONSTANT_ALPHA 0x00008003 -#define NV20TCL_BLEND_FUNC_SRC_ONE_MINUS_CONSTANT_ALPHA 0x00008004 -#define NV20TCL_BLEND_FUNC_DST 0x00000348 -#define NV20TCL_BLEND_FUNC_DST_ZERO 0x00000000 -#define NV20TCL_BLEND_FUNC_DST_ONE 0x00000001 -#define NV20TCL_BLEND_FUNC_DST_SRC_COLOR 0x00000300 -#define NV20TCL_BLEND_FUNC_DST_ONE_MINUS_SRC_COLOR 0x00000301 -#define NV20TCL_BLEND_FUNC_DST_SRC_ALPHA 0x00000302 -#define NV20TCL_BLEND_FUNC_DST_ONE_MINUS_SRC_ALPHA 0x00000303 -#define NV20TCL_BLEND_FUNC_DST_DST_ALPHA 0x00000304 -#define NV20TCL_BLEND_FUNC_DST_ONE_MINUS_DST_ALPHA 0x00000305 -#define NV20TCL_BLEND_FUNC_DST_DST_COLOR 0x00000306 -#define NV20TCL_BLEND_FUNC_DST_ONE_MINUS_DST_COLOR 0x00000307 -#define NV20TCL_BLEND_FUNC_DST_SRC_ALPHA_SATURATE 0x00000308 -#define NV20TCL_BLEND_FUNC_DST_CONSTANT_COLOR 0x00008001 -#define NV20TCL_BLEND_FUNC_DST_ONE_MINUS_CONSTANT_COLOR 0x00008002 -#define NV20TCL_BLEND_FUNC_DST_CONSTANT_ALPHA 0x00008003 -#define NV20TCL_BLEND_FUNC_DST_ONE_MINUS_CONSTANT_ALPHA 0x00008004 -#define NV20TCL_BLEND_COLOR 0x0000034c -#define NV20TCL_BLEND_COLOR_B_SHIFT 0 -#define NV20TCL_BLEND_COLOR_B_MASK 0x000000ff -#define NV20TCL_BLEND_COLOR_G_SHIFT 8 -#define NV20TCL_BLEND_COLOR_G_MASK 0x0000ff00 -#define NV20TCL_BLEND_COLOR_R_SHIFT 16 -#define NV20TCL_BLEND_COLOR_R_MASK 0x00ff0000 -#define NV20TCL_BLEND_COLOR_A_SHIFT 24 -#define NV20TCL_BLEND_COLOR_A_MASK 0xff000000 -#define NV20TCL_BLEND_EQUATION 0x00000350 -#define NV20TCL_BLEND_EQUATION_FUNC_ADD 0x00008006 -#define NV20TCL_BLEND_EQUATION_MIN 0x00008007 -#define NV20TCL_BLEND_EQUATION_MAX 0x00008008 -#define NV20TCL_BLEND_EQUATION_FUNC_SUBTRACT 0x0000800a -#define NV20TCL_BLEND_EQUATION_FUNC_REVERSE_SUBTRACT 0x0000800b -#define NV20TCL_DEPTH_FUNC 0x00000354 -#define NV20TCL_DEPTH_FUNC_NEVER 0x00000200 -#define NV20TCL_DEPTH_FUNC_LESS 0x00000201 -#define NV20TCL_DEPTH_FUNC_EQUAL 0x00000202 -#define NV20TCL_DEPTH_FUNC_LEQUAL 0x00000203 -#define NV20TCL_DEPTH_FUNC_GREATER 0x00000204 -#define NV20TCL_DEPTH_FUNC_NOTEQUAL 0x00000205 -#define NV20TCL_DEPTH_FUNC_GEQUAL 0x00000206 -#define NV20TCL_DEPTH_FUNC_ALWAYS 0x00000207 -#define NV20TCL_COLOR_MASK 0x00000358 -#define NV20TCL_COLOR_MASK_B (1 << 0) -#define NV20TCL_COLOR_MASK_G (1 << 8) -#define NV20TCL_COLOR_MASK_R (1 << 16) -#define NV20TCL_COLOR_MASK_A (1 << 24) -#define NV20TCL_DEPTH_WRITE_ENABLE 0x0000035c -#define NV20TCL_STENCIL_MASK 0x00000360 -#define NV20TCL_STENCIL_FUNC_FUNC 0x00000364 -#define NV20TCL_STENCIL_FUNC_FUNC_NEVER 0x00000200 -#define NV20TCL_STENCIL_FUNC_FUNC_LESS 0x00000201 -#define NV20TCL_STENCIL_FUNC_FUNC_EQUAL 0x00000202 -#define NV20TCL_STENCIL_FUNC_FUNC_LEQUAL 0x00000203 -#define NV20TCL_STENCIL_FUNC_FUNC_GREATER 0x00000204 -#define NV20TCL_STENCIL_FUNC_FUNC_NOTEQUAL 0x00000205 -#define NV20TCL_STENCIL_FUNC_FUNC_GEQUAL 0x00000206 -#define NV20TCL_STENCIL_FUNC_FUNC_ALWAYS 0x00000207 -#define NV20TCL_STENCIL_FUNC_REF 0x00000368 -#define NV20TCL_STENCIL_FUNC_MASK 0x0000036c -#define NV20TCL_STENCIL_OP_FAIL 0x00000370 -#define NV20TCL_STENCIL_OP_FAIL_ZERO 0x00000000 -#define NV20TCL_STENCIL_OP_FAIL_INVERT 0x0000150a -#define NV20TCL_STENCIL_OP_FAIL_KEEP 0x00001e00 -#define NV20TCL_STENCIL_OP_FAIL_REPLACE 0x00001e01 -#define NV20TCL_STENCIL_OP_FAIL_INCR 0x00001e02 -#define NV20TCL_STENCIL_OP_FAIL_DECR 0x00001e03 -#define NV20TCL_STENCIL_OP_FAIL_INCR_WRAP 0x00008507 -#define NV20TCL_STENCIL_OP_FAIL_DECR_WRAP 0x00008508 -#define NV20TCL_STENCIL_OP_ZFAIL 0x00000374 -#define NV20TCL_STENCIL_OP_ZFAIL_ZERO 0x00000000 -#define NV20TCL_STENCIL_OP_ZFAIL_INVERT 0x0000150a -#define NV20TCL_STENCIL_OP_ZFAIL_KEEP 0x00001e00 -#define NV20TCL_STENCIL_OP_ZFAIL_REPLACE 0x00001e01 -#define NV20TCL_STENCIL_OP_ZFAIL_INCR 0x00001e02 -#define NV20TCL_STENCIL_OP_ZFAIL_DECR 0x00001e03 -#define NV20TCL_STENCIL_OP_ZFAIL_INCR_WRAP 0x00008507 -#define NV20TCL_STENCIL_OP_ZFAIL_DECR_WRAP 0x00008508 -#define NV20TCL_STENCIL_OP_ZPASS 0x00000378 -#define NV20TCL_STENCIL_OP_ZPASS_ZERO 0x00000000 -#define NV20TCL_STENCIL_OP_ZPASS_INVERT 0x0000150a -#define NV20TCL_STENCIL_OP_ZPASS_KEEP 0x00001e00 -#define NV20TCL_STENCIL_OP_ZPASS_REPLACE 0x00001e01 -#define NV20TCL_STENCIL_OP_ZPASS_INCR 0x00001e02 -#define NV20TCL_STENCIL_OP_ZPASS_DECR 0x00001e03 -#define NV20TCL_STENCIL_OP_ZPASS_INCR_WRAP 0x00008507 -#define NV20TCL_STENCIL_OP_ZPASS_DECR_WRAP 0x00008508 -#define NV20TCL_SHADE_MODEL 0x0000037c -#define NV20TCL_SHADE_MODEL_FLAT 0x00001d00 -#define NV20TCL_SHADE_MODEL_SMOOTH 0x00001d01 -#define NV20TCL_LINE_WIDTH 0x00000380 -#define NV20TCL_POLYGON_OFFSET_FACTOR 0x00000384 -#define NV20TCL_POLYGON_OFFSET_UNITS 0x00000388 -#define NV20TCL_POLYGON_MODE_FRONT 0x0000038c -#define NV20TCL_POLYGON_MODE_FRONT_POINT 0x00001b00 -#define NV20TCL_POLYGON_MODE_FRONT_LINE 0x00001b01 -#define NV20TCL_POLYGON_MODE_FRONT_FILL 0x00001b02 -#define NV20TCL_POLYGON_MODE_BACK 0x00000390 -#define NV20TCL_POLYGON_MODE_BACK_POINT 0x00001b00 -#define NV20TCL_POLYGON_MODE_BACK_LINE 0x00001b01 -#define NV20TCL_POLYGON_MODE_BACK_FILL 0x00001b02 -#define NV20TCL_DEPTH_RANGE_NEAR 0x00000394 -#define NV20TCL_DEPTH_RANGE_FAR 0x00000398 -#define NV20TCL_CULL_FACE 0x0000039c -#define NV20TCL_CULL_FACE_FRONT 0x00000404 -#define NV20TCL_CULL_FACE_BACK 0x00000405 -#define NV20TCL_CULL_FACE_FRONT_AND_BACK 0x00000408 -#define NV20TCL_FRONT_FACE 0x000003a0 -#define NV20TCL_FRONT_FACE_CW 0x00000900 -#define NV20TCL_FRONT_FACE_CCW 0x00000901 -#define NV20TCL_NORMALIZE_ENABLE 0x000003a4 -#define NV20TCL_MATERIAL_FACTOR_FRONT_R 0x000003a8 -#define NV20TCL_MATERIAL_FACTOR_FRONT_G 0x000003ac -#define NV20TCL_MATERIAL_FACTOR_FRONT_B 0x000003b0 -#define NV20TCL_MATERIAL_FACTOR_FRONT_A 0x000003b4 -#define NV20TCL_SEPARATE_SPECULAR_ENABLE 0x000003b8 -#define NV20TCL_ENABLED_LIGHTS 0x000003bc -#define NV20TCL_ENABLED_LIGHTS_0_SHIFT 0 -#define NV20TCL_ENABLED_LIGHTS_0_MASK 0x00000003 -#define NV20TCL_ENABLED_LIGHTS_0_DISABLED 0x00000000 -#define NV20TCL_ENABLED_LIGHTS_0_NONPOSITIONAL 0x00000001 -#define NV20TCL_ENABLED_LIGHTS_0_POSITIONAL 0x00000002 -#define NV20TCL_ENABLED_LIGHTS_0_DIRECTIONAL 0x00000003 -#define NV20TCL_ENABLED_LIGHTS_1_SHIFT 2 -#define NV20TCL_ENABLED_LIGHTS_1_MASK 0x0000000c -#define NV20TCL_ENABLED_LIGHTS_1_DISABLED 0x00000000 -#define NV20TCL_ENABLED_LIGHTS_1_NONPOSITIONAL 0x00000004 -#define NV20TCL_ENABLED_LIGHTS_1_POSITIONAL 0x00000008 -#define NV20TCL_ENABLED_LIGHTS_1_DIRECTIONAL 0x0000000c -#define NV20TCL_ENABLED_LIGHTS_2_SHIFT 4 -#define NV20TCL_ENABLED_LIGHTS_2_MASK 0x00000030 -#define NV20TCL_ENABLED_LIGHTS_2_DISABLED 0x00000000 -#define NV20TCL_ENABLED_LIGHTS_2_NONPOSITIONAL 0x00000010 -#define NV20TCL_ENABLED_LIGHTS_2_POSITIONAL 0x00000020 -#define NV20TCL_ENABLED_LIGHTS_2_DIRECTIONAL 0x00000030 -#define NV20TCL_ENABLED_LIGHTS_3_SHIFT 6 -#define NV20TCL_ENABLED_LIGHTS_3_MASK 0x000000c0 -#define NV20TCL_ENABLED_LIGHTS_3_DISABLED 0x00000000 -#define NV20TCL_ENABLED_LIGHTS_3_NONPOSITIONAL 0x00000040 -#define NV20TCL_ENABLED_LIGHTS_3_POSITIONAL 0x00000080 -#define NV20TCL_ENABLED_LIGHTS_3_DIRECTIONAL 0x000000c0 -#define NV20TCL_ENABLED_LIGHTS_4_SHIFT 8 -#define NV20TCL_ENABLED_LIGHTS_4_MASK 0x00000300 -#define NV20TCL_ENABLED_LIGHTS_4_DISABLED 0x00000000 -#define NV20TCL_ENABLED_LIGHTS_4_NONPOSITIONAL 0x00000100 -#define NV20TCL_ENABLED_LIGHTS_4_POSITIONAL 0x00000200 -#define NV20TCL_ENABLED_LIGHTS_4_DIRECTIONAL 0x00000300 -#define NV20TCL_ENABLED_LIGHTS_5_SHIFT 10 -#define NV20TCL_ENABLED_LIGHTS_5_MASK 0x00000c00 -#define NV20TCL_ENABLED_LIGHTS_5_DISABLED 0x00000000 -#define NV20TCL_ENABLED_LIGHTS_5_NONPOSITIONAL 0x00000400 -#define NV20TCL_ENABLED_LIGHTS_5_POSITIONAL 0x00000800 -#define NV20TCL_ENABLED_LIGHTS_5_DIRECTIONAL 0x00000c00 -#define NV20TCL_ENABLED_LIGHTS_6_SHIFT 12 -#define NV20TCL_ENABLED_LIGHTS_6_MASK 0x00003000 -#define NV20TCL_ENABLED_LIGHTS_6_DISABLED 0x00000000 -#define NV20TCL_ENABLED_LIGHTS_6_NONPOSITIONAL 0x00001000 -#define NV20TCL_ENABLED_LIGHTS_6_POSITIONAL 0x00002000 -#define NV20TCL_ENABLED_LIGHTS_6_DIRECTIONAL 0x00003000 -#define NV20TCL_ENABLED_LIGHTS_7_SHIFT 14 -#define NV20TCL_ENABLED_LIGHTS_7_MASK 0x0000c000 -#define NV20TCL_ENABLED_LIGHTS_7_DISABLED 0x00000000 -#define NV20TCL_ENABLED_LIGHTS_7_NONPOSITIONAL 0x00004000 -#define NV20TCL_ENABLED_LIGHTS_7_POSITIONAL 0x00008000 -#define NV20TCL_ENABLED_LIGHTS_7_DIRECTIONAL 0x0000c000 -#define NV20TCL_TX_GEN_MODE_S(x) (0x000003c0+((x)*16)) -#define NV20TCL_TX_GEN_MODE_S__SIZE 0x00000004 -#define NV20TCL_TX_GEN_MODE_S_FALSE 0x00000000 -#define NV20TCL_TX_GEN_MODE_S_EYE_LINEAR 0x00002400 -#define NV20TCL_TX_GEN_MODE_S_OBJECT_LINEAR 0x00002401 -#define NV20TCL_TX_GEN_MODE_S_SPHERE_MAP 0x00002402 -#define NV20TCL_TX_GEN_MODE_S_NORMAL_MAP 0x00008511 -#define NV20TCL_TX_GEN_MODE_S_REFLECTION_MAP 0x00008512 -#define NV20TCL_TX_GEN_MODE_T(x) (0x000003c4+((x)*16)) -#define NV20TCL_TX_GEN_MODE_T__SIZE 0x00000004 -#define NV20TCL_TX_GEN_MODE_T_FALSE 0x00000000 -#define NV20TCL_TX_GEN_MODE_T_EYE_LINEAR 0x00002400 -#define NV20TCL_TX_GEN_MODE_T_OBJECT_LINEAR 0x00002401 -#define NV20TCL_TX_GEN_MODE_T_SPHERE_MAP 0x00002402 -#define NV20TCL_TX_GEN_MODE_T_NORMAL_MAP 0x00008511 -#define NV20TCL_TX_GEN_MODE_T_REFLECTION_MAP 0x00008512 -#define NV20TCL_TX_GEN_MODE_R(x) (0x000003c8+((x)*16)) -#define NV20TCL_TX_GEN_MODE_R__SIZE 0x00000004 -#define NV20TCL_TX_GEN_MODE_R_FALSE 0x00000000 -#define NV20TCL_TX_GEN_MODE_R_EYE_LINEAR 0x00002400 -#define NV20TCL_TX_GEN_MODE_R_OBJECT_LINEAR 0x00002401 -#define NV20TCL_TX_GEN_MODE_R_SPHERE_MAP 0x00002402 -#define NV20TCL_TX_GEN_MODE_R_NORMAL_MAP 0x00008511 -#define NV20TCL_TX_GEN_MODE_R_REFLECTION_MAP 0x00008512 -#define NV20TCL_TX_GEN_MODE_Q(x) (0x000003cc+((x)*16)) -#define NV20TCL_TX_GEN_MODE_Q__SIZE 0x00000004 -#define NV20TCL_TX_GEN_MODE_Q_FALSE 0x00000000 -#define NV20TCL_TX_GEN_MODE_Q_EYE_LINEAR 0x00002400 -#define NV20TCL_TX_GEN_MODE_Q_OBJECT_LINEAR 0x00002401 -#define NV20TCL_TX_GEN_MODE_Q_SPHERE_MAP 0x00002402 -#define NV20TCL_TX_GEN_MODE_Q_NORMAL_MAP 0x00008511 -#define NV20TCL_TX_GEN_MODE_Q_REFLECTION_MAP 0x00008512 -#define NV20TCL_TX_MATRIX_ENABLE(x) (0x00000420+((x)*4)) -#define NV20TCL_TX_MATRIX_ENABLE__SIZE 0x00000004 -#define NV20TCL_POINT_SIZE 0x0000043c -#define NV20TCL_MODELVIEW0_MATRIX(x) (0x00000480+((x)*4)) -#define NV20TCL_MODELVIEW0_MATRIX__SIZE 0x00000010 -#define NV20TCL_MODELVIEW1_MATRIX(x) (0x000004c0+((x)*4)) -#define NV20TCL_MODELVIEW1_MATRIX__SIZE 0x00000010 -#define NV20TCL_MODELVIEW2_MATRIX(x) (0x00000500+((x)*4)) -#define NV20TCL_MODELVIEW2_MATRIX__SIZE 0x00000010 -#define NV20TCL_MODELVIEW3_MATRIX(x) (0x00000540+((x)*4)) -#define NV20TCL_MODELVIEW3_MATRIX__SIZE 0x00000010 -#define NV20TCL_INVERSE_MODELVIEW0_MATRIX(x) (0x00000580+((x)*4)) -#define NV20TCL_INVERSE_MODELVIEW0_MATRIX__SIZE 0x00000010 -#define NV20TCL_INVERSE_MODELVIEW1_MATRIX(x) (0x000005c0+((x)*4)) -#define NV20TCL_INVERSE_MODELVIEW1_MATRIX__SIZE 0x00000010 -#define NV20TCL_INVERSE_MODELVIEW2_MATRIX(x) (0x00000600+((x)*4)) -#define NV20TCL_INVERSE_MODELVIEW2_MATRIX__SIZE 0x00000010 -#define NV20TCL_INVERSE_MODELVIEW3_MATRIX(x) (0x00000640+((x)*4)) -#define NV20TCL_INVERSE_MODELVIEW3_MATRIX__SIZE 0x00000010 -#define NV20TCL_PROJECTION_MATRIX(x) (0x00000680+((x)*4)) -#define NV20TCL_PROJECTION_MATRIX__SIZE 0x00000010 -#define NV20TCL_TX0_MATRIX(x) (0x000006c0+((x)*4)) -#define NV20TCL_TX0_MATRIX__SIZE 0x00000010 -#define NV20TCL_TX1_MATRIX(x) (0x00000700+((x)*4)) -#define NV20TCL_TX1_MATRIX__SIZE 0x00000010 -#define NV20TCL_TX2_MATRIX(x) (0x00000740+((x)*4)) -#define NV20TCL_TX2_MATRIX__SIZE 0x00000010 -#define NV20TCL_TX3_MATRIX(x) (0x00000780+((x)*4)) -#define NV20TCL_TX3_MATRIX__SIZE 0x00000010 -#define NV20TCL_TX_GEN_COEFF_S_A(x) (0x00000840+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_S_A__SIZE 0x00000004 -#define NV20TCL_TX_GEN_COEFF_S_B(x) (0x00000844+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_S_B__SIZE 0x00000004 -#define NV20TCL_TX_GEN_COEFF_S_C(x) (0x00000848+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_S_C__SIZE 0x00000004 -#define NV20TCL_TX_GEN_COEFF_S_D(x) (0x0000084c+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_S_D__SIZE 0x00000004 -#define NV20TCL_TX_GEN_COEFF_T_A(x) (0x00000850+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_T_A__SIZE 0x00000004 -#define NV20TCL_TX_GEN_COEFF_T_B(x) (0x00000854+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_T_B__SIZE 0x00000004 -#define NV20TCL_TX_GEN_COEFF_T_C(x) (0x00000858+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_T_C__SIZE 0x00000004 -#define NV20TCL_TX_GEN_COEFF_T_D(x) (0x0000085c+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_T_D__SIZE 0x00000004 -#define NV20TCL_TX_GEN_COEFF_R_A(x) (0x00000860+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_R_A__SIZE 0x00000004 -#define NV20TCL_TX_GEN_COEFF_R_B(x) (0x00000864+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_R_B__SIZE 0x00000004 -#define NV20TCL_TX_GEN_COEFF_R_C(x) (0x00000868+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_R_C__SIZE 0x00000004 -#define NV20TCL_TX_GEN_COEFF_R_D(x) (0x0000086c+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_R_D__SIZE 0x00000004 -#define NV20TCL_TX_GEN_COEFF_Q_A(x) (0x00000870+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_Q_A__SIZE 0x00000004 -#define NV20TCL_TX_GEN_COEFF_Q_B(x) (0x00000874+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_Q_B__SIZE 0x00000004 -#define NV20TCL_TX_GEN_COEFF_Q_C(x) (0x00000878+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_Q_C__SIZE 0x00000004 -#define NV20TCL_TX_GEN_COEFF_Q_D(x) (0x0000087c+((x)*64)) -#define NV20TCL_TX_GEN_COEFF_Q_D__SIZE 0x00000004 -#define NV20TCL_FOG_EQUATION_CONSTANT 0x000009c0 -#define NV20TCL_FOG_EQUATION_LINEAR 0x000009c4 -#define NV20TCL_FOG_EQUATION_QUADRATIC 0x000009c8 -#define NV20TCL_FRONT_MATERIAL_SHININESS(x) (0x000009e0+((x)*4)) -#define NV20TCL_FRONT_MATERIAL_SHININESS__SIZE 0x00000006 -#define NV20TCL_LIGHT_MODEL_FRONT_AMBIENT_R 0x00000a10 -#define NV20TCL_LIGHT_MODEL_FRONT_AMBIENT_G 0x00000a14 -#define NV20TCL_LIGHT_MODEL_FRONT_AMBIENT_B 0x00000a18 -#define NV20TCL_VIEWPORT_TRANSLATE_X 0x00000a20 -#define NV20TCL_VIEWPORT_TRANSLATE_Y 0x00000a24 -#define NV20TCL_VIEWPORT_TRANSLATE_Z 0x00000a28 -#define NV20TCL_VIEWPORT_TRANSLATE_W 0x00000a2c -#define NV20TCL_POINT_PARAMETER(x) (0x00000a30+((x)*4)) -#define NV20TCL_POINT_PARAMETER__SIZE 0x00000008 -#define NV20TCL_RC_CONSTANT_COLOR0(x) (0x00000a60+((x)*4)) -#define NV20TCL_RC_CONSTANT_COLOR0__SIZE 0x00000008 -#define NV20TCL_RC_CONSTANT_COLOR0_B_SHIFT 0 -#define NV20TCL_RC_CONSTANT_COLOR0_B_MASK 0x000000ff -#define NV20TCL_RC_CONSTANT_COLOR0_G_SHIFT 8 -#define NV20TCL_RC_CONSTANT_COLOR0_G_MASK 0x0000ff00 -#define NV20TCL_RC_CONSTANT_COLOR0_R_SHIFT 16 -#define NV20TCL_RC_CONSTANT_COLOR0_R_MASK 0x00ff0000 -#define NV20TCL_RC_CONSTANT_COLOR0_A_SHIFT 24 -#define NV20TCL_RC_CONSTANT_COLOR0_A_MASK 0xff000000 -#define NV20TCL_RC_CONSTANT_COLOR1(x) (0x00000a80+((x)*4)) -#define NV20TCL_RC_CONSTANT_COLOR1__SIZE 0x00000008 -#define NV20TCL_RC_CONSTANT_COLOR1_B_SHIFT 0 -#define NV20TCL_RC_CONSTANT_COLOR1_B_MASK 0x000000ff -#define NV20TCL_RC_CONSTANT_COLOR1_G_SHIFT 8 -#define NV20TCL_RC_CONSTANT_COLOR1_G_MASK 0x0000ff00 -#define NV20TCL_RC_CONSTANT_COLOR1_R_SHIFT 16 -#define NV20TCL_RC_CONSTANT_COLOR1_R_MASK 0x00ff0000 -#define NV20TCL_RC_CONSTANT_COLOR1_A_SHIFT 24 -#define NV20TCL_RC_CONSTANT_COLOR1_A_MASK 0xff000000 -#define NV20TCL_RC_OUT_ALPHA(x) (0x00000aa0+((x)*4)) -#define NV20TCL_RC_OUT_ALPHA__SIZE 0x00000008 -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_SHIFT 0 -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_MASK 0x0000000f -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_ZERO 0x00000000 -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_CONSTANT_COLOR0 0x00000001 -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_CONSTANT_COLOR1 0x00000002 -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_FOG 0x00000003 -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_PRIMARY_COLOR 0x00000004 -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_SECONDARY_COLOR 0x00000005 -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE0 0x00000008 -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE1 0x00000009 -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_SPARE0 0x0000000c -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_SPARE1 0x0000000d -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_E_TIMES_F 0x0000000f -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE2 0x0000000a -#define NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE3 0x0000000b -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_SHIFT 4 -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_MASK 0x000000f0 -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_ZERO 0x00000000 -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_CONSTANT_COLOR0 0x00000010 -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_CONSTANT_COLOR1 0x00000020 -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_FOG 0x00000030 -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_PRIMARY_COLOR 0x00000040 -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_SECONDARY_COLOR 0x00000050 -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE0 0x00000080 -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE1 0x00000090 -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_SPARE0 0x000000c0 -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_SPARE1 0x000000d0 -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000000e0 -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_E_TIMES_F 0x000000f0 -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE2 0x000000a0 -#define NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE3 0x000000b0 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_SHIFT 8 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_MASK 0x00000f00 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_ZERO 0x00000000 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_CONSTANT_COLOR0 0x00000100 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_CONSTANT_COLOR1 0x00000200 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_FOG 0x00000300 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_PRIMARY_COLOR 0x00000400 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_SECONDARY_COLOR 0x00000500 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE0 0x00000800 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE1 0x00000900 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_SPARE0 0x00000c00 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_SPARE1 0x00000d00 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_E_TIMES_F 0x00000f00 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE2 0x00000a00 -#define NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE3 0x00000b00 -#define NV20TCL_RC_OUT_ALPHA_CD_DOT_PRODUCT (1 << 12) -#define NV20TCL_RC_OUT_ALPHA_AB_DOT_PRODUCT (1 << 13) -#define NV20TCL_RC_OUT_ALPHA_MUX_SUM (1 << 14) -#define NV20TCL_RC_OUT_ALPHA_BIAS (1 << 15) -#define NV20TCL_RC_OUT_ALPHA_BIAS_NONE 0x00000000 -#define NV20TCL_RC_OUT_ALPHA_BIAS_BIAS_BY_NEGATIVE_ONE_HALF 0x00008000 -#define NV20TCL_RC_OUT_ALPHA_SCALE_SHIFT 16 -#define NV20TCL_RC_OUT_ALPHA_SCALE_MASK 0x00030000 -#define NV20TCL_RC_OUT_ALPHA_SCALE_NONE 0x00000000 -#define NV20TCL_RC_OUT_ALPHA_SCALE_SCALE_BY_TWO 0x00010000 -#define NV20TCL_RC_OUT_ALPHA_SCALE_SCALE_BY_FOUR 0x00020000 -#define NV20TCL_RC_OUT_ALPHA_SCALE_SCALE_BY_ONE_HALF 0x00030000 -#define NV20TCL_RC_IN_RGB(x) (0x00000ac0+((x)*4)) -#define NV20TCL_RC_IN_RGB__SIZE 0x00000008 -#define NV20TCL_RC_IN_RGB_D_INPUT_SHIFT 0 -#define NV20TCL_RC_IN_RGB_D_INPUT_MASK 0x0000000f -#define NV20TCL_RC_IN_RGB_D_INPUT_ZERO 0x00000000 -#define NV20TCL_RC_IN_RGB_D_INPUT_CONSTANT_COLOR0 0x00000001 -#define NV20TCL_RC_IN_RGB_D_INPUT_CONSTANT_COLOR1 0x00000002 -#define NV20TCL_RC_IN_RGB_D_INPUT_FOG 0x00000003 -#define NV20TCL_RC_IN_RGB_D_INPUT_PRIMARY_COLOR 0x00000004 -#define NV20TCL_RC_IN_RGB_D_INPUT_SECONDARY_COLOR 0x00000005 -#define NV20TCL_RC_IN_RGB_D_INPUT_TEXTURE0 0x00000008 -#define NV20TCL_RC_IN_RGB_D_INPUT_TEXTURE1 0x00000009 -#define NV20TCL_RC_IN_RGB_D_INPUT_SPARE0 0x0000000c -#define NV20TCL_RC_IN_RGB_D_INPUT_SPARE1 0x0000000d -#define NV20TCL_RC_IN_RGB_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e -#define NV20TCL_RC_IN_RGB_D_INPUT_E_TIMES_F 0x0000000f -#define NV20TCL_RC_IN_RGB_D_INPUT_TEXTURE2 0x0000000a -#define NV20TCL_RC_IN_RGB_D_INPUT_TEXTURE3 0x0000000b -#define NV20TCL_RC_IN_RGB_D_COMPONENT_USAGE (1 << 4) -#define NV20TCL_RC_IN_RGB_D_COMPONENT_USAGE_RGB 0x00000000 -#define NV20TCL_RC_IN_RGB_D_COMPONENT_USAGE_ALPHA 0x00000010 -#define NV20TCL_RC_IN_RGB_D_MAPPING_SHIFT 5 -#define NV20TCL_RC_IN_RGB_D_MAPPING_MASK 0x000000e0 -#define NV20TCL_RC_IN_RGB_D_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV20TCL_RC_IN_RGB_D_MAPPING_UNSIGNED_INVERT 0x00000020 -#define NV20TCL_RC_IN_RGB_D_MAPPING_EXPAND_NORMAL 0x00000040 -#define NV20TCL_RC_IN_RGB_D_MAPPING_EXPAND_NEGATE 0x00000060 -#define NV20TCL_RC_IN_RGB_D_MAPPING_HALF_BIAS_NORMAL 0x00000080 -#define NV20TCL_RC_IN_RGB_D_MAPPING_HALF_BIAS_NEGATE 0x000000a0 -#define NV20TCL_RC_IN_RGB_D_MAPPING_SIGNED_IDENTITY 0x000000c0 -#define NV20TCL_RC_IN_RGB_D_MAPPING_SIGNED_NEGATE 0x000000e0 -#define NV20TCL_RC_IN_RGB_C_INPUT_SHIFT 8 -#define NV20TCL_RC_IN_RGB_C_INPUT_MASK 0x00000f00 -#define NV20TCL_RC_IN_RGB_C_INPUT_ZERO 0x00000000 -#define NV20TCL_RC_IN_RGB_C_INPUT_CONSTANT_COLOR0 0x00000100 -#define NV20TCL_RC_IN_RGB_C_INPUT_CONSTANT_COLOR1 0x00000200 -#define NV20TCL_RC_IN_RGB_C_INPUT_FOG 0x00000300 -#define NV20TCL_RC_IN_RGB_C_INPUT_PRIMARY_COLOR 0x00000400 -#define NV20TCL_RC_IN_RGB_C_INPUT_SECONDARY_COLOR 0x00000500 -#define NV20TCL_RC_IN_RGB_C_INPUT_TEXTURE0 0x00000800 -#define NV20TCL_RC_IN_RGB_C_INPUT_TEXTURE1 0x00000900 -#define NV20TCL_RC_IN_RGB_C_INPUT_SPARE0 0x00000c00 -#define NV20TCL_RC_IN_RGB_C_INPUT_SPARE1 0x00000d00 -#define NV20TCL_RC_IN_RGB_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 -#define NV20TCL_RC_IN_RGB_C_INPUT_E_TIMES_F 0x00000f00 -#define NV20TCL_RC_IN_RGB_C_INPUT_TEXTURE2 0x00000a00 -#define NV20TCL_RC_IN_RGB_C_INPUT_TEXTURE3 0x00000b00 -#define NV20TCL_RC_IN_RGB_C_COMPONENT_USAGE (1 << 12) -#define NV20TCL_RC_IN_RGB_C_COMPONENT_USAGE_RGB 0x00000000 -#define NV20TCL_RC_IN_RGB_C_COMPONENT_USAGE_ALPHA 0x00001000 -#define NV20TCL_RC_IN_RGB_C_MAPPING_SHIFT 13 -#define NV20TCL_RC_IN_RGB_C_MAPPING_MASK 0x0000e000 -#define NV20TCL_RC_IN_RGB_C_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV20TCL_RC_IN_RGB_C_MAPPING_UNSIGNED_INVERT 0x00002000 -#define NV20TCL_RC_IN_RGB_C_MAPPING_EXPAND_NORMAL 0x00004000 -#define NV20TCL_RC_IN_RGB_C_MAPPING_EXPAND_NEGATE 0x00006000 -#define NV20TCL_RC_IN_RGB_C_MAPPING_HALF_BIAS_NORMAL 0x00008000 -#define NV20TCL_RC_IN_RGB_C_MAPPING_HALF_BIAS_NEGATE 0x0000a000 -#define NV20TCL_RC_IN_RGB_C_MAPPING_SIGNED_IDENTITY 0x0000c000 -#define NV20TCL_RC_IN_RGB_C_MAPPING_SIGNED_NEGATE 0x0000e000 -#define NV20TCL_RC_IN_RGB_B_INPUT_SHIFT 16 -#define NV20TCL_RC_IN_RGB_B_INPUT_MASK 0x000f0000 -#define NV20TCL_RC_IN_RGB_B_INPUT_ZERO 0x00000000 -#define NV20TCL_RC_IN_RGB_B_INPUT_CONSTANT_COLOR0 0x00010000 -#define NV20TCL_RC_IN_RGB_B_INPUT_CONSTANT_COLOR1 0x00020000 -#define NV20TCL_RC_IN_RGB_B_INPUT_FOG 0x00030000 -#define NV20TCL_RC_IN_RGB_B_INPUT_PRIMARY_COLOR 0x00040000 -#define NV20TCL_RC_IN_RGB_B_INPUT_SECONDARY_COLOR 0x00050000 -#define NV20TCL_RC_IN_RGB_B_INPUT_TEXTURE0 0x00080000 -#define NV20TCL_RC_IN_RGB_B_INPUT_TEXTURE1 0x00090000 -#define NV20TCL_RC_IN_RGB_B_INPUT_SPARE0 0x000c0000 -#define NV20TCL_RC_IN_RGB_B_INPUT_SPARE1 0x000d0000 -#define NV20TCL_RC_IN_RGB_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 -#define NV20TCL_RC_IN_RGB_B_INPUT_E_TIMES_F 0x000f0000 -#define NV20TCL_RC_IN_RGB_B_INPUT_TEXTURE2 0x000a0000 -#define NV20TCL_RC_IN_RGB_B_INPUT_TEXTURE3 0x000b0000 -#define NV20TCL_RC_IN_RGB_B_COMPONENT_USAGE (1 << 20) -#define NV20TCL_RC_IN_RGB_B_COMPONENT_USAGE_RGB 0x00000000 -#define NV20TCL_RC_IN_RGB_B_COMPONENT_USAGE_ALPHA 0x00100000 -#define NV20TCL_RC_IN_RGB_B_MAPPING_SHIFT 21 -#define NV20TCL_RC_IN_RGB_B_MAPPING_MASK 0x00e00000 -#define NV20TCL_RC_IN_RGB_B_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV20TCL_RC_IN_RGB_B_MAPPING_UNSIGNED_INVERT 0x00200000 -#define NV20TCL_RC_IN_RGB_B_MAPPING_EXPAND_NORMAL 0x00400000 -#define NV20TCL_RC_IN_RGB_B_MAPPING_EXPAND_NEGATE 0x00600000 -#define NV20TCL_RC_IN_RGB_B_MAPPING_HALF_BIAS_NORMAL 0x00800000 -#define NV20TCL_RC_IN_RGB_B_MAPPING_HALF_BIAS_NEGATE 0x00a00000 -#define NV20TCL_RC_IN_RGB_B_MAPPING_SIGNED_IDENTITY 0x00c00000 -#define NV20TCL_RC_IN_RGB_B_MAPPING_SIGNED_NEGATE 0x00e00000 -#define NV20TCL_RC_IN_RGB_A_INPUT_SHIFT 24 -#define NV20TCL_RC_IN_RGB_A_INPUT_MASK 0x0f000000 -#define NV20TCL_RC_IN_RGB_A_INPUT_ZERO 0x00000000 -#define NV20TCL_RC_IN_RGB_A_INPUT_CONSTANT_COLOR0 0x01000000 -#define NV20TCL_RC_IN_RGB_A_INPUT_CONSTANT_COLOR1 0x02000000 -#define NV20TCL_RC_IN_RGB_A_INPUT_FOG 0x03000000 -#define NV20TCL_RC_IN_RGB_A_INPUT_PRIMARY_COLOR 0x04000000 -#define NV20TCL_RC_IN_RGB_A_INPUT_SECONDARY_COLOR 0x05000000 -#define NV20TCL_RC_IN_RGB_A_INPUT_TEXTURE0 0x08000000 -#define NV20TCL_RC_IN_RGB_A_INPUT_TEXTURE1 0x09000000 -#define NV20TCL_RC_IN_RGB_A_INPUT_SPARE0 0x0c000000 -#define NV20TCL_RC_IN_RGB_A_INPUT_SPARE1 0x0d000000 -#define NV20TCL_RC_IN_RGB_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 -#define NV20TCL_RC_IN_RGB_A_INPUT_E_TIMES_F 0x0f000000 -#define NV20TCL_RC_IN_RGB_A_INPUT_TEXTURE2 0x0a000000 -#define NV20TCL_RC_IN_RGB_A_INPUT_TEXTURE3 0x0b000000 -#define NV20TCL_RC_IN_RGB_A_COMPONENT_USAGE (1 << 28) -#define NV20TCL_RC_IN_RGB_A_COMPONENT_USAGE_RGB 0x00000000 -#define NV20TCL_RC_IN_RGB_A_COMPONENT_USAGE_ALPHA 0x10000000 -#define NV20TCL_RC_IN_RGB_A_MAPPING_SHIFT 29 -#define NV20TCL_RC_IN_RGB_A_MAPPING_MASK 0xe0000000 -#define NV20TCL_RC_IN_RGB_A_MAPPING_UNSIGNED_IDENTITY 0x00000000 -#define NV20TCL_RC_IN_RGB_A_MAPPING_UNSIGNED_INVERT 0x20000000 -#define NV20TCL_RC_IN_RGB_A_MAPPING_EXPAND_NORMAL 0x40000000 -#define NV20TCL_RC_IN_RGB_A_MAPPING_EXPAND_NEGATE 0x60000000 -#define NV20TCL_RC_IN_RGB_A_MAPPING_HALF_BIAS_NORMAL 0x80000000 -#define NV20TCL_RC_IN_RGB_A_MAPPING_HALF_BIAS_NEGATE 0xa0000000 -#define NV20TCL_RC_IN_RGB_A_MAPPING_SIGNED_IDENTITY 0xc0000000 -#define NV20TCL_RC_IN_RGB_A_MAPPING_SIGNED_NEGATE 0xe0000000 -#define NV20TCL_VIEWPORT_SCALE_X 0x00000af0 -#define NV20TCL_VIEWPORT_SCALE_Y 0x00000af4 -#define NV20TCL_VIEWPORT_SCALE_Z 0x00000af8 -#define NV20TCL_VIEWPORT_SCALE_W 0x00000afc -#define NV20TCL_VP_UPLOAD_INST(x) (0x00000b00+((x)*4)) -#define NV20TCL_VP_UPLOAD_INST__SIZE 0x00000004 -#define NV20TCL_VP_UPLOAD_CONST(x) (0x00000b80+((x)*4)) -#define NV20TCL_VP_UPLOAD_CONST__SIZE 0x00000004 -#define NV20TCL_LIGHT_BACK_AMBIENT_R(x) (0x00000c00+((x)*64)) -#define NV20TCL_LIGHT_BACK_AMBIENT_R__SIZE 0x00000008 -#define NV20TCL_LIGHT_BACK_AMBIENT_G(x) (0x00000c04+((x)*64)) -#define NV20TCL_LIGHT_BACK_AMBIENT_G__SIZE 0x00000008 -#define NV20TCL_LIGHT_BACK_AMBIENT_B(x) (0x00000c08+((x)*64)) -#define NV20TCL_LIGHT_BACK_AMBIENT_B__SIZE 0x00000008 -#define NV20TCL_LIGHT_BACK_DIFFUSE_R(x) (0x00000c0c+((x)*64)) -#define NV20TCL_LIGHT_BACK_DIFFUSE_R__SIZE 0x00000008 -#define NV20TCL_LIGHT_BACK_DIFFUSE_G(x) (0x00000c10+((x)*64)) -#define NV20TCL_LIGHT_BACK_DIFFUSE_G__SIZE 0x00000008 -#define NV20TCL_LIGHT_BACK_DIFFUSE_B(x) (0x00000c14+((x)*64)) -#define NV20TCL_LIGHT_BACK_DIFFUSE_B__SIZE 0x00000008 -#define NV20TCL_LIGHT_BACK_SPECULAR_R(x) (0x00000c18+((x)*64)) -#define NV20TCL_LIGHT_BACK_SPECULAR_R__SIZE 0x00000008 -#define NV20TCL_LIGHT_BACK_SPECULAR_G(x) (0x00000c1c+((x)*64)) -#define NV20TCL_LIGHT_BACK_SPECULAR_G__SIZE 0x00000008 -#define NV20TCL_LIGHT_BACK_SPECULAR_B(x) (0x00000c20+((x)*64)) -#define NV20TCL_LIGHT_BACK_SPECULAR_B__SIZE 0x00000008 -#define NV20TCL_LIGHT_FRONT_AMBIENT_R(x) (0x00001000+((x)*128)) -#define NV20TCL_LIGHT_FRONT_AMBIENT_R__SIZE 0x00000008 -#define NV20TCL_LIGHT_FRONT_AMBIENT_G(x) (0x00001004+((x)*128)) -#define NV20TCL_LIGHT_FRONT_AMBIENT_G__SIZE 0x00000008 -#define NV20TCL_LIGHT_FRONT_AMBIENT_B(x) (0x00001008+((x)*128)) -#define NV20TCL_LIGHT_FRONT_AMBIENT_B__SIZE 0x00000008 -#define NV20TCL_LIGHT_FRONT_DIFFUSE_R(x) (0x0000100c+((x)*128)) -#define NV20TCL_LIGHT_FRONT_DIFFUSE_R__SIZE 0x00000008 -#define NV20TCL_LIGHT_FRONT_DIFFUSE_G(x) (0x00001010+((x)*128)) -#define NV20TCL_LIGHT_FRONT_DIFFUSE_G__SIZE 0x00000008 -#define NV20TCL_LIGHT_FRONT_DIFFUSE_B(x) (0x00001014+((x)*128)) -#define NV20TCL_LIGHT_FRONT_DIFFUSE_B__SIZE 0x00000008 -#define NV20TCL_LIGHT_FRONT_SPECULAR_R(x) (0x00001018+((x)*128)) -#define NV20TCL_LIGHT_FRONT_SPECULAR_R__SIZE 0x00000008 -#define NV20TCL_LIGHT_FRONT_SPECULAR_G(x) (0x0000101c+((x)*128)) -#define NV20TCL_LIGHT_FRONT_SPECULAR_G__SIZE 0x00000008 -#define NV20TCL_LIGHT_FRONT_SPECULAR_B(x) (0x00001020+((x)*128)) -#define NV20TCL_LIGHT_FRONT_SPECULAR_B__SIZE 0x00000008 -#define NV20TCL_LIGHT_HALF_VECTOR_X(x) (0x00001028+((x)*128)) -#define NV20TCL_LIGHT_HALF_VECTOR_X__SIZE 0x00000008 -#define NV20TCL_LIGHT_HALF_VECTOR_Y(x) (0x0000102c+((x)*128)) -#define NV20TCL_LIGHT_HALF_VECTOR_Y__SIZE 0x00000008 -#define NV20TCL_LIGHT_HALF_VECTOR_Z(x) (0x00001030+((x)*128)) -#define NV20TCL_LIGHT_HALF_VECTOR_Z__SIZE 0x00000008 -#define NV20TCL_LIGHT_DIRECTION_X(x) (0x00001034+((x)*128)) -#define NV20TCL_LIGHT_DIRECTION_X__SIZE 0x00000008 -#define NV20TCL_LIGHT_DIRECTION_Y(x) (0x00001038+((x)*128)) -#define NV20TCL_LIGHT_DIRECTION_Y__SIZE 0x00000008 -#define NV20TCL_LIGHT_DIRECTION_Z(x) (0x0000103c+((x)*128)) -#define NV20TCL_LIGHT_DIRECTION_Z__SIZE 0x00000008 -#define NV20TCL_LIGHT_SPOT_CUTOFF_A(x) (0x00001040+((x)*128)) -#define NV20TCL_LIGHT_SPOT_CUTOFF_A__SIZE 0x00000008 -#define NV20TCL_LIGHT_SPOT_CUTOFF_B(x) (0x00001044+((x)*128)) -#define NV20TCL_LIGHT_SPOT_CUTOFF_B__SIZE 0x00000008 -#define NV20TCL_LIGHT_SPOT_CUTOFF_C(x) (0x00001048+((x)*128)) -#define NV20TCL_LIGHT_SPOT_CUTOFF_C__SIZE 0x00000008 -#define NV20TCL_LIGHT_SPOT_DIR_X(x) (0x0000104c+((x)*128)) -#define NV20TCL_LIGHT_SPOT_DIR_X__SIZE 0x00000008 -#define NV20TCL_LIGHT_SPOT_DIR_Y(x) (0x00001050+((x)*128)) -#define NV20TCL_LIGHT_SPOT_DIR_Y__SIZE 0x00000008 -#define NV20TCL_LIGHT_SPOT_DIR_Z(x) (0x00001054+((x)*128)) -#define NV20TCL_LIGHT_SPOT_DIR_Z__SIZE 0x00000008 -#define NV20TCL_LIGHT_SPOT_CUTOFF_D(x) (0x00001058+((x)*128)) -#define NV20TCL_LIGHT_SPOT_CUTOFF_D__SIZE 0x00000008 -#define NV20TCL_LIGHT_POSITION_X(x) (0x0000105c+((x)*128)) -#define NV20TCL_LIGHT_POSITION_X__SIZE 0x00000008 -#define NV20TCL_LIGHT_POSITION_Y(x) (0x00001060+((x)*128)) -#define NV20TCL_LIGHT_POSITION_Y__SIZE 0x00000008 -#define NV20TCL_LIGHT_POSITION_Z(x) (0x00001064+((x)*128)) -#define NV20TCL_LIGHT_POSITION_Z__SIZE 0x00000008 -#define NV20TCL_LIGHT_ATTENUATION_CONSTANT(x) (0x00001068+((x)*128)) -#define NV20TCL_LIGHT_ATTENUATION_CONSTANT__SIZE 0x00000008 -#define NV20TCL_LIGHT_ATTENUATION_LINEAR(x) (0x0000106c+((x)*128)) -#define NV20TCL_LIGHT_ATTENUATION_LINEAR__SIZE 0x00000008 -#define NV20TCL_LIGHT_ATTENUATION_QUADRATIC(x) (0x00001070+((x)*128)) -#define NV20TCL_LIGHT_ATTENUATION_QUADRATIC__SIZE 0x00000008 -#define NV20TCL_POLYGON_STIPPLE_ENABLE 0x0000147c -#define NV20TCL_POLYGON_STIPPLE_PATTERN(x) (0x00001480+((x)*4)) -#define NV20TCL_POLYGON_STIPPLE_PATTERN__SIZE 0x00000020 -#define NV20TCL_VERTEX_POS_3F_X 0x00001500 -#define NV20TCL_VERTEX_POS_3F_Y 0x00001504 -#define NV20TCL_VERTEX_POS_3F_Z 0x00001508 -#define NV20TCL_VERTEX_POS_4F_X 0x00001518 -#define NV20TCL_VERTEX_POS_4F_Y 0x0000151c -#define NV20TCL_VERTEX_POS_4F_Z 0x00001520 -#define NV20TCL_VERTEX_POS_3I_XY 0x00001528 -#define NV20TCL_VERTEX_POS_3I_XY_X_SHIFT 0 -#define NV20TCL_VERTEX_POS_3I_XY_X_MASK 0x0000ffff -#define NV20TCL_VERTEX_POS_3I_XY_Y_SHIFT 16 -#define NV20TCL_VERTEX_POS_3I_XY_Y_MASK 0xffff0000 -#define NV20TCL_VERTEX_POS_3I_Z 0x0000152c -#define NV20TCL_VERTEX_POS_3I_Z_Z_SHIFT 0 -#define NV20TCL_VERTEX_POS_3I_Z_Z_MASK 0x0000ffff -#define NV20TCL_VERTEX_NOR_3F_X 0x00001530 -#define NV20TCL_VERTEX_NOR_3F_Y 0x00001534 -#define NV20TCL_VERTEX_NOR_3F_Z 0x00001538 -#define NV20TCL_VERTEX_NOR_3I_XY 0x00001540 -#define NV20TCL_VERTEX_NOR_3I_XY_X_SHIFT 0 -#define NV20TCL_VERTEX_NOR_3I_XY_X_MASK 0x0000ffff -#define NV20TCL_VERTEX_NOR_3I_XY_Y_SHIFT 16 -#define NV20TCL_VERTEX_NOR_3I_XY_Y_MASK 0xffff0000 -#define NV20TCL_VERTEX_NOR_3I_Z 0x00001544 -#define NV20TCL_VERTEX_NOR_3I_Z_Z_SHIFT 0 -#define NV20TCL_VERTEX_NOR_3I_Z_Z_MASK 0x0000ffff -#define NV20TCL_VERTEX_COL_4F_X 0x00001550 -#define NV20TCL_VERTEX_COL_4F_Y 0x00001554 -#define NV20TCL_VERTEX_COL_4F_Z 0x00001558 -#define NV20TCL_VERTEX_COL_4F_W 0x0000155c -#define NV20TCL_VERTEX_COL_3F_X 0x00001560 -#define NV20TCL_VERTEX_COL_3F_Y 0x00001564 -#define NV20TCL_VERTEX_COL_3F_Z 0x00001568 -#define NV20TCL_VERTEX_COL_4I 0x0000156c -#define NV20TCL_VERTEX_COL_4I_R_SHIFT 0 -#define NV20TCL_VERTEX_COL_4I_R_MASK 0x000000ff -#define NV20TCL_VERTEX_COL_4I_G_SHIFT 8 -#define NV20TCL_VERTEX_COL_4I_G_MASK 0x0000ff00 -#define NV20TCL_VERTEX_COL_4I_B_SHIFT 16 -#define NV20TCL_VERTEX_COL_4I_B_MASK 0x00ff0000 -#define NV20TCL_VERTEX_COL_4I_A_SHIFT 24 -#define NV20TCL_VERTEX_COL_4I_A_MASK 0xff000000 -#define NV20TCL_VERTEX_COL2_3F_X 0x00001580 -#define NV20TCL_VERTEX_COL2_3F_Y 0x00001584 -#define NV20TCL_VERTEX_COL2_3F_Z 0x00001588 -#define NV20TCL_VERTEX_COL2_4I 0x0000158c -#define NV20TCL_VERTEX_COL2_4I_R_SHIFT 0 -#define NV20TCL_VERTEX_COL2_4I_R_MASK 0x000000ff -#define NV20TCL_VERTEX_COL2_4I_G_SHIFT 8 -#define NV20TCL_VERTEX_COL2_4I_G_MASK 0x0000ff00 -#define NV20TCL_VERTEX_COL2_4I_B_SHIFT 16 -#define NV20TCL_VERTEX_COL2_4I_B_MASK 0x00ff0000 -#define NV20TCL_VERTEX_COL2_4I_A_SHIFT 24 -#define NV20TCL_VERTEX_COL2_4I_A_MASK 0xff000000 -#define NV20TCL_VERTEX_TX0_2F_S 0x00001590 -#define NV20TCL_VERTEX_TX0_2F_T 0x00001594 -#define NV20TCL_VERTEX_TX0_2I 0x00001598 -#define NV20TCL_VERTEX_TX0_2I_S_SHIFT 0 -#define NV20TCL_VERTEX_TX0_2I_S_MASK 0x0000ffff -#define NV20TCL_VERTEX_TX0_2I_T_SHIFT 16 -#define NV20TCL_VERTEX_TX0_2I_T_MASK 0xffff0000 -#define NV20TCL_VERTEX_TX0_4F_S 0x000015a0 -#define NV20TCL_VERTEX_TX0_4F_T 0x000015a4 -#define NV20TCL_VERTEX_TX0_4F_R 0x000015a8 -#define NV20TCL_VERTEX_TX0_4F_Q 0x000015ac -#define NV20TCL_VERTEX_TX0_4I_ST 0x000015b0 -#define NV20TCL_VERTEX_TX0_4I_ST_S_SHIFT 0 -#define NV20TCL_VERTEX_TX0_4I_ST_S_MASK 0x0000ffff -#define NV20TCL_VERTEX_TX0_4I_ST_T_SHIFT 16 -#define NV20TCL_VERTEX_TX0_4I_ST_T_MASK 0xffff0000 -#define NV20TCL_VERTEX_TX0_4I_RQ 0x000015b4 -#define NV20TCL_VERTEX_TX0_4I_RQ_R_SHIFT 0 -#define NV20TCL_VERTEX_TX0_4I_RQ_R_MASK 0x0000ffff -#define NV20TCL_VERTEX_TX0_4I_RQ_Q_SHIFT 16 -#define NV20TCL_VERTEX_TX0_4I_RQ_Q_MASK 0xffff0000 -#define NV20TCL_VERTEX_TX1_2F_S 0x000015b8 -#define NV20TCL_VERTEX_TX1_2F_T 0x000015bc -#define NV20TCL_VERTEX_TX1_2I 0x000015c0 -#define NV20TCL_VERTEX_TX1_2I_S_SHIFT 0 -#define NV20TCL_VERTEX_TX1_2I_S_MASK 0x0000ffff -#define NV20TCL_VERTEX_TX1_2I_T_SHIFT 16 -#define NV20TCL_VERTEX_TX1_2I_T_MASK 0xffff0000 -#define NV20TCL_VERTEX_TX1_4F_S 0x000015c8 -#define NV20TCL_VERTEX_TX1_4F_T 0x000015cc -#define NV20TCL_VERTEX_TX1_4F_R 0x000015d0 -#define NV20TCL_VERTEX_TX1_4F_Q 0x000015d4 -#define NV20TCL_VERTEX_TX1_4I_ST 0x000015d8 -#define NV20TCL_VERTEX_TX1_4I_ST_S_SHIFT 0 -#define NV20TCL_VERTEX_TX1_4I_ST_S_MASK 0x0000ffff -#define NV20TCL_VERTEX_TX1_4I_ST_T_SHIFT 16 -#define NV20TCL_VERTEX_TX1_4I_ST_T_MASK 0xffff0000 -#define NV20TCL_VERTEX_TX1_4I_RQ 0x000015dc -#define NV20TCL_VERTEX_TX1_4I_RQ_R_SHIFT 0 -#define NV20TCL_VERTEX_TX1_4I_RQ_R_MASK 0x0000ffff -#define NV20TCL_VERTEX_TX1_4I_RQ_Q_SHIFT 16 -#define NV20TCL_VERTEX_TX1_4I_RQ_Q_MASK 0xffff0000 -#define NV20TCL_VERTEX_TX2_2F_S 0x000015e0 -#define NV20TCL_VERTEX_TX2_2F_T 0x000015e4 -#define NV20TCL_VERTEX_TX2_2I 0x000015e8 -#define NV20TCL_VERTEX_TX2_2I_S_SHIFT 0 -#define NV20TCL_VERTEX_TX2_2I_S_MASK 0x0000ffff -#define NV20TCL_VERTEX_TX2_2I_T_SHIFT 16 -#define NV20TCL_VERTEX_TX2_2I_T_MASK 0xffff0000 -#define NV20TCL_VERTEX_TX2_4F_S 0x000015f0 -#define NV20TCL_VERTEX_TX2_4F_T 0x000015f4 -#define NV20TCL_VERTEX_TX2_4F_R 0x000015f8 -#define NV20TCL_VERTEX_TX2_4F_Q 0x000015fc -#define NV20TCL_VERTEX_TX2_4I_ST 0x00001600 -#define NV20TCL_VERTEX_TX2_4I_ST_S_SHIFT 0 -#define NV20TCL_VERTEX_TX2_4I_ST_S_MASK 0x0000ffff -#define NV20TCL_VERTEX_TX2_4I_ST_T_SHIFT 16 -#define NV20TCL_VERTEX_TX2_4I_ST_T_MASK 0xffff0000 -#define NV20TCL_VERTEX_TX2_4I_RQ 0x00001604 -#define NV20TCL_VERTEX_TX2_4I_RQ_R_SHIFT 0 -#define NV20TCL_VERTEX_TX2_4I_RQ_R_MASK 0x0000ffff -#define NV20TCL_VERTEX_TX2_4I_RQ_Q_SHIFT 16 -#define NV20TCL_VERTEX_TX2_4I_RQ_Q_MASK 0xffff0000 -#define NV20TCL_VERTEX_TX3_2F_S 0x00001608 -#define NV20TCL_VERTEX_TX3_2F_T 0x0000160c -#define NV20TCL_VERTEX_TX3_2I 0x00001610 -#define NV20TCL_VERTEX_TX3_2I_S_SHIFT 0 -#define NV20TCL_VERTEX_TX3_2I_S_MASK 0x0000ffff -#define NV20TCL_VERTEX_TX3_2I_T_SHIFT 16 -#define NV20TCL_VERTEX_TX3_2I_T_MASK 0xffff0000 -#define NV20TCL_VERTEX_TX3_4F_S 0x00001620 -#define NV20TCL_VERTEX_TX3_4F_T 0x00001624 -#define NV20TCL_VERTEX_TX3_4F_R 0x00001628 -#define NV20TCL_VERTEX_TX3_4F_Q 0x0000162c -#define NV20TCL_VERTEX_TX3_4I_ST 0x00001630 -#define NV20TCL_VERTEX_TX3_4I_ST_S_SHIFT 0 -#define NV20TCL_VERTEX_TX3_4I_ST_S_MASK 0x0000ffff -#define NV20TCL_VERTEX_TX3_4I_ST_T_SHIFT 16 -#define NV20TCL_VERTEX_TX3_4I_ST_T_MASK 0xffff0000 -#define NV20TCL_VERTEX_TX3_4I_RQ 0x00001634 -#define NV20TCL_VERTEX_TX3_4I_RQ_R_SHIFT 0 -#define NV20TCL_VERTEX_TX3_4I_RQ_R_MASK 0x0000ffff -#define NV20TCL_VERTEX_TX3_4I_RQ_Q_SHIFT 16 -#define NV20TCL_VERTEX_TX3_4I_RQ_Q_MASK 0xffff0000 -#define NV20TCL_VERTEX_FOG_1F 0x00001698 -#define NV20TCL_EDGEFLAG_ENABLE 0x000016bc -#define NV20TCL_VTX_CACHE_INVALIDATE 0x00001710 -#define NV20TCL_VTXBUF_ADDRESS(x) (0x00001720+((x)*4)) -#define NV20TCL_VTXBUF_ADDRESS__SIZE 0x00000010 -#define NV20TCL_VTXBUF_ADDRESS_DMA1 (1 << 31) -#define NV20TCL_VTXBUF_ADDRESS_OFFSET_SHIFT 0 -#define NV20TCL_VTXBUF_ADDRESS_OFFSET_MASK 0x0fffffff -#define NV20TCL_VTXFMT(x) (0x00001760+((x)*4)) -#define NV20TCL_VTXFMT__SIZE 0x00000010 -#define NV20TCL_VTXFMT_TYPE_SHIFT 0 -#define NV20TCL_VTXFMT_TYPE_MASK 0x0000000f -#define NV20TCL_VTXFMT_TYPE_FLOAT 0x00000002 -#define NV20TCL_VTXFMT_TYPE_UBYTE 0x00000004 -#define NV20TCL_VTXFMT_TYPE_USHORT 0x00000005 -#define NV20TCL_VTXFMT_SIZE_SHIFT 4 -#define NV20TCL_VTXFMT_SIZE_MASK 0x000000f0 -#define NV20TCL_VTXFMT_STRIDE_SHIFT 8 -#define NV20TCL_VTXFMT_STRIDE_MASK 0x0000ff00 -#define NV20TCL_LIGHT_MODEL_BACK_AMBIENT_R 0x000017a0 -#define NV20TCL_LIGHT_MODEL_BACK_AMBIENT_G 0x000017a4 -#define NV20TCL_LIGHT_MODEL_BACK_AMBIENT_B 0x000017a8 -#define NV20TCL_MATERIAL_FACTOR_BACK_A 0x000017ac -#define NV20TCL_MATERIAL_FACTOR_BACK_R 0x000017b0 -#define NV20TCL_MATERIAL_FACTOR_BACK_G 0x000017b4 -#define NV20TCL_MATERIAL_FACTOR_BACK_B 0x000017b8 -#define NV20TCL_COLOR_LOGIC_OP_ENABLE 0x000017bc -#define NV20TCL_COLOR_LOGIC_OP_OP 0x000017c0 -#define NV20TCL_COLOR_LOGIC_OP_OP_CLEAR 0x00001500 -#define NV20TCL_COLOR_LOGIC_OP_OP_AND 0x00001501 -#define NV20TCL_COLOR_LOGIC_OP_OP_AND_REVERSE 0x00001502 -#define NV20TCL_COLOR_LOGIC_OP_OP_COPY 0x00001503 -#define NV20TCL_COLOR_LOGIC_OP_OP_AND_INVERTED 0x00001504 -#define NV20TCL_COLOR_LOGIC_OP_OP_NOOP 0x00001505 -#define NV20TCL_COLOR_LOGIC_OP_OP_XOR 0x00001506 -#define NV20TCL_COLOR_LOGIC_OP_OP_OR 0x00001507 -#define NV20TCL_COLOR_LOGIC_OP_OP_NOR 0x00001508 -#define NV20TCL_COLOR_LOGIC_OP_OP_EQUIV 0x00001509 -#define NV20TCL_COLOR_LOGIC_OP_OP_INVERT 0x0000150a -#define NV20TCL_COLOR_LOGIC_OP_OP_OR_REVERSE 0x0000150b -#define NV20TCL_COLOR_LOGIC_OP_OP_COPY_INVERTED 0x0000150c -#define NV20TCL_COLOR_LOGIC_OP_OP_OR_INVERTED 0x0000150d -#define NV20TCL_COLOR_LOGIC_OP_OP_NAND 0x0000150e -#define NV20TCL_COLOR_LOGIC_OP_OP_SET 0x0000150f -#define NV20TCL_LIGHT_MODEL_TWO_SIDE_ENABLE 0x000017c4 -#define NV20TCL_TX_SHADER_CULL_MODE 0x000017f8 -#define NV20TCL_TX_SHADER_CULL_MODE_TX0_S (1 << 0) -#define NV20TCL_TX_SHADER_CULL_MODE_TX0_S_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX0_S_LESS 0x00000001 -#define NV20TCL_TX_SHADER_CULL_MODE_TX0_T (1 << 1) -#define NV20TCL_TX_SHADER_CULL_MODE_TX0_T_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX0_T_LESS 0x00000002 -#define NV20TCL_TX_SHADER_CULL_MODE_TX0_R (1 << 2) -#define NV20TCL_TX_SHADER_CULL_MODE_TX0_R_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX0_R_LESS 0x00000004 -#define NV20TCL_TX_SHADER_CULL_MODE_TX0_Q (1 << 3) -#define NV20TCL_TX_SHADER_CULL_MODE_TX0_Q_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX0_Q_LESS 0x00000008 -#define NV20TCL_TX_SHADER_CULL_MODE_TX1_S (1 << 4) -#define NV20TCL_TX_SHADER_CULL_MODE_TX1_S_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX1_S_LESS 0x00000010 -#define NV20TCL_TX_SHADER_CULL_MODE_TX1_T (1 << 5) -#define NV20TCL_TX_SHADER_CULL_MODE_TX1_T_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX1_T_LESS 0x00000020 -#define NV20TCL_TX_SHADER_CULL_MODE_TX1_R (1 << 6) -#define NV20TCL_TX_SHADER_CULL_MODE_TX1_R_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX1_R_LESS 0x00000040 -#define NV20TCL_TX_SHADER_CULL_MODE_TX1_Q (1 << 7) -#define NV20TCL_TX_SHADER_CULL_MODE_TX1_Q_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX1_Q_LESS 0x00000080 -#define NV20TCL_TX_SHADER_CULL_MODE_TX2_S (1 << 8) -#define NV20TCL_TX_SHADER_CULL_MODE_TX2_S_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX2_S_LESS 0x00000100 -#define NV20TCL_TX_SHADER_CULL_MODE_TX2_T (1 << 9) -#define NV20TCL_TX_SHADER_CULL_MODE_TX2_T_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX2_T_LESS 0x00000200 -#define NV20TCL_TX_SHADER_CULL_MODE_TX2_R (1 << 10) -#define NV20TCL_TX_SHADER_CULL_MODE_TX2_R_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX2_R_LESS 0x00000400 -#define NV20TCL_TX_SHADER_CULL_MODE_TX2_Q (1 << 11) -#define NV20TCL_TX_SHADER_CULL_MODE_TX2_Q_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX2_Q_LESS 0x00000800 -#define NV20TCL_TX_SHADER_CULL_MODE_TX3_S (1 << 12) -#define NV20TCL_TX_SHADER_CULL_MODE_TX3_S_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX3_S_LESS 0x00001000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX3_T (1 << 13) -#define NV20TCL_TX_SHADER_CULL_MODE_TX3_T_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX3_T_LESS 0x00002000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX3_R (1 << 14) -#define NV20TCL_TX_SHADER_CULL_MODE_TX3_R_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX3_R_LESS 0x00004000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX3_Q (1 << 15) -#define NV20TCL_TX_SHADER_CULL_MODE_TX3_Q_GEQUAL 0x00000000 -#define NV20TCL_TX_SHADER_CULL_MODE_TX3_Q_LESS 0x00008000 -#define NV20TCL_VERTEX_BEGIN_END 0x000017fc -#define NV20TCL_VERTEX_BEGIN_END_STOP 0x00000000 -#define NV20TCL_VERTEX_BEGIN_END_POINTS 0x00000001 -#define NV20TCL_VERTEX_BEGIN_END_LINES 0x00000002 -#define NV20TCL_VERTEX_BEGIN_END_LINE_LOOP 0x00000003 -#define NV20TCL_VERTEX_BEGIN_END_LINE_STRIP 0x00000004 -#define NV20TCL_VERTEX_BEGIN_END_TRIANGLES 0x00000005 -#define NV20TCL_VERTEX_BEGIN_END_TRIANGLE_STRIP 0x00000006 -#define NV20TCL_VERTEX_BEGIN_END_TRIANGLE_FAN 0x00000007 -#define NV20TCL_VERTEX_BEGIN_END_QUADS 0x00000008 -#define NV20TCL_VERTEX_BEGIN_END_QUAD_STRIP 0x00000009 -#define NV20TCL_VERTEX_BEGIN_END_POLYGON 0x0000000a -#define NV20TCL_VB_ELEMENT_U16 0x00001800 -#define NV20TCL_VB_ELEMENT_U16_I0_SHIFT 0 -#define NV20TCL_VB_ELEMENT_U16_I0_MASK 0x0000ffff -#define NV20TCL_VB_ELEMENT_U16_I1_SHIFT 16 -#define NV20TCL_VB_ELEMENT_U16_I1_MASK 0xffff0000 -#define NV20TCL_VB_ELEMENT_U32 0x00001808 -#define NV20TCL_VB_VERTEX_BATCH 0x00001810 -#define NV20TCL_VB_VERTEX_BATCH_OFFSET_SHIFT 0 -#define NV20TCL_VB_VERTEX_BATCH_OFFSET_MASK 0x00ffffff -#define NV20TCL_VB_VERTEX_BATCH_COUNT_SHIFT 24 -#define NV20TCL_VB_VERTEX_BATCH_COUNT_MASK 0xff000000 -#define NV20TCL_VERTEX_DATA 0x00001818 -#define NV20TCL_TX_SHADER_CONST_EYE_X 0x0000181c -#define NV20TCL_TX_SHADER_CONST_EYE_Y 0x00001820 -#define NV20TCL_TX_SHADER_CONST_EYE_Z 0x00001824 -#define NV20TCL_VTX_ATTR_4F_X(x) (0x00001a00+((x)*16)) -#define NV20TCL_VTX_ATTR_4F_X__SIZE 0x00000010 -#define NV20TCL_VTX_ATTR_4F_Y(x) (0x00001a04+((x)*16)) -#define NV20TCL_VTX_ATTR_4F_Y__SIZE 0x00000010 -#define NV20TCL_VTX_ATTR_4F_Z(x) (0x00001a08+((x)*16)) -#define NV20TCL_VTX_ATTR_4F_Z__SIZE 0x00000010 -#define NV20TCL_VTX_ATTR_4F_W(x) (0x00001a0c+((x)*16)) -#define NV20TCL_VTX_ATTR_4F_W__SIZE 0x00000010 -#define NV20TCL_TX_OFFSET(x) (0x00001b00+((x)*64)) -#define NV20TCL_TX_OFFSET__SIZE 0x00000004 -#define NV20TCL_TX_FORMAT(x) (0x00001b04+((x)*64)) -#define NV20TCL_TX_FORMAT__SIZE 0x00000004 -#define NV20TCL_TX_FORMAT_DMA0 (1 << 0) -#define NV20TCL_TX_FORMAT_DMA1 (1 << 1) -#define NV20TCL_TX_FORMAT_CUBIC (1 << 2) -#define NV20TCL_TX_FORMAT_NO_BORDER (1 << 3) -#define NV20TCL_TX_FORMAT_DIMS_SHIFT 4 -#define NV20TCL_TX_FORMAT_DIMS_MASK 0x000000f0 -#define NV20TCL_TX_FORMAT_DIMS_1D 0x00000010 -#define NV20TCL_TX_FORMAT_DIMS_2D 0x00000020 -#define NV20TCL_TX_FORMAT_DIMS_3D 0x00000030 -#define NV20TCL_TX_FORMAT_FORMAT_SHIFT 8 -#define NV20TCL_TX_FORMAT_FORMAT_MASK 0x0000ff00 -#define NV20TCL_TX_FORMAT_FORMAT_L8 0x00000000 -#define NV20TCL_TX_FORMAT_FORMAT_A8 0x00000100 -#define NV20TCL_TX_FORMAT_FORMAT_A1R5G5B5 0x00000200 -#define NV20TCL_TX_FORMAT_FORMAT_A4R4G4B4 0x00000400 -#define NV20TCL_TX_FORMAT_FORMAT_R5G6B5 0x00000500 -#define NV20TCL_TX_FORMAT_FORMAT_A8R8G8B8 0x00000600 -#define NV20TCL_TX_FORMAT_FORMAT_X8R8G8B8 0x00000700 -#define NV20TCL_TX_FORMAT_FORMAT_INDEX8 0x00000b00 -#define NV20TCL_TX_FORMAT_FORMAT_DXT1 0x00000c00 -#define NV20TCL_TX_FORMAT_FORMAT_DXT3 0x00000e00 -#define NV20TCL_TX_FORMAT_FORMAT_DXT5 0x00000f00 -#define NV20TCL_TX_FORMAT_FORMAT_A1R5G5B5_RECT 0x00001000 -#define NV20TCL_TX_FORMAT_FORMAT_R5G6B5_RECT 0x00001100 -#define NV20TCL_TX_FORMAT_FORMAT_A8R8G8B8_RECT 0x00001200 -#define NV20TCL_TX_FORMAT_FORMAT_L8_RECT 0x00001300 -#define NV20TCL_TX_FORMAT_FORMAT_DSDT8_RECT 0x00001700 -#define NV20TCL_TX_FORMAT_FORMAT_A8L8 0x00001a00 -#define NV20TCL_TX_FORMAT_FORMAT_A8_RECT 0x00001b00 -#define NV20TCL_TX_FORMAT_FORMAT_A4R4G4B4_RECT 0x00001d00 -#define NV20TCL_TX_FORMAT_FORMAT_R8G8B8_RECT 0x00001e00 -#define NV20TCL_TX_FORMAT_FORMAT_A8L8_RECT 0x00002000 -#define NV20TCL_TX_FORMAT_FORMAT_DSDT8 0x00002800 -#define NV20TCL_TX_FORMAT_FORMAT_HILO16 0x00003300 -#define NV20TCL_TX_FORMAT_FORMAT_HILO16_RECT 0x00003600 -#define NV20TCL_TX_FORMAT_FORMAT_HILO8 0x00004400 -#define NV20TCL_TX_FORMAT_FORMAT_SIGNED_HILO8 0x00004500 -#define NV20TCL_TX_FORMAT_FORMAT_HILO8_RECT 0x00004600 -#define NV20TCL_TX_FORMAT_FORMAT_SIGNED_HILO8_RECT 0x00004700 -#define NV20TCL_TX_FORMAT_FORMAT_A16 0x00003200 -#define NV20TCL_TX_FORMAT_FORMAT_A16_RECT 0x00003500 -#define NV20TCL_TX_FORMAT_FORMAT_FLOAT_RGBA16_NV 0x00004a00 -#define NV20TCL_TX_FORMAT_FORMAT_FLOAT_RGBA32_NV 0x00004b00 -#define NV20TCL_TX_FORMAT_FORMAT_FLOAT_R32_NV 0x00004c00 -#define NV20TCL_TX_FORMAT_MIPMAP (1 << 19) -#define NV20TCL_TX_FORMAT_BASE_SIZE_U_SHIFT 20 -#define NV20TCL_TX_FORMAT_BASE_SIZE_U_MASK 0x00f00000 -#define NV20TCL_TX_FORMAT_BASE_SIZE_V_SHIFT 24 -#define NV20TCL_TX_FORMAT_BASE_SIZE_V_MASK 0x0f000000 -#define NV20TCL_TX_FORMAT_BASE_SIZE_W_SHIFT 28 -#define NV20TCL_TX_FORMAT_BASE_SIZE_W_MASK 0xf0000000 -#define NV20TCL_TX_WRAP(x) (0x00001b08+((x)*64)) -#define NV20TCL_TX_WRAP__SIZE 0x00000004 -#define NV20TCL_TX_WRAP_S_SHIFT 0 -#define NV20TCL_TX_WRAP_S_MASK 0x000000ff -#define NV20TCL_TX_WRAP_S_REPEAT 0x00000001 -#define NV20TCL_TX_WRAP_S_MIRRORED_REPEAT 0x00000002 -#define NV20TCL_TX_WRAP_S_CLAMP_TO_EDGE 0x00000003 -#define NV20TCL_TX_WRAP_S_CLAMP_TO_BORDER 0x00000004 -#define NV20TCL_TX_WRAP_S_CLAMP 0x00000005 -#define NV20TCL_TX_WRAP_T_SHIFT 8 -#define NV20TCL_TX_WRAP_T_MASK 0x00000f00 -#define NV20TCL_TX_WRAP_T_REPEAT 0x00000100 -#define NV20TCL_TX_WRAP_T_MIRRORED_REPEAT 0x00000200 -#define NV20TCL_TX_WRAP_T_CLAMP_TO_EDGE 0x00000300 -#define NV20TCL_TX_WRAP_T_CLAMP_TO_BORDER 0x00000400 -#define NV20TCL_TX_WRAP_T_CLAMP 0x00000500 -#define NV20TCL_TX_WRAP_R_SHIFT 16 -#define NV20TCL_TX_WRAP_R_MASK 0x000f0000 -#define NV20TCL_TX_WRAP_R_REPEAT 0x00010000 -#define NV20TCL_TX_WRAP_R_MIRRORED_REPEAT 0x00020000 -#define NV20TCL_TX_WRAP_R_CLAMP_TO_EDGE 0x00030000 -#define NV20TCL_TX_WRAP_R_CLAMP_TO_BORDER 0x00040000 -#define NV20TCL_TX_WRAP_R_CLAMP 0x00050000 -#define NV20TCL_TX_ENABLE(x) (0x00001b0c+((x)*64)) -#define NV20TCL_TX_ENABLE__SIZE 0x00000004 -#define NV20TCL_TX_ENABLE_ANISO_SHIFT 4 -#define NV20TCL_TX_ENABLE_ANISO_MASK 0x00000030 -#define NV20TCL_TX_ENABLE_ANISO_NONE 0x00000000 -#define NV20TCL_TX_ENABLE_ANISO_2X 0x00000010 -#define NV20TCL_TX_ENABLE_ANISO_4X 0x00000020 -#define NV20TCL_TX_ENABLE_ANISO_8X 0x00000030 -#define NV20TCL_TX_ENABLE_MIPMAP_MAX_LOD_SHIFT 14 -#define NV20TCL_TX_ENABLE_MIPMAP_MAX_LOD_MASK 0x0003c000 -#define NV20TCL_TX_ENABLE_MIPMAP_MIN_LOD_SHIFT 26 -#define NV20TCL_TX_ENABLE_MIPMAP_MIN_LOD_MASK 0x3c000000 -#define NV20TCL_TX_ENABLE_ENABLE (1 << 30) -#define NV20TCL_TX_NPOT_PITCH(x) (0x00001b10+((x)*64)) -#define NV20TCL_TX_NPOT_PITCH__SIZE 0x00000004 -#define NV20TCL_TX_NPOT_PITCH_PITCH_SHIFT 16 -#define NV20TCL_TX_NPOT_PITCH_PITCH_MASK 0xffff0000 -#define NV20TCL_TX_FILTER(x) (0x00001b14+((x)*64)) -#define NV20TCL_TX_FILTER__SIZE 0x00000004 -#define NV20TCL_TX_FILTER_LOD_BIAS_SHIFT 8 -#define NV20TCL_TX_FILTER_LOD_BIAS_MASK 0x00000f00 -#define NV20TCL_TX_FILTER_MINIFY_SHIFT 16 -#define NV20TCL_TX_FILTER_MINIFY_MASK 0x000f0000 -#define NV20TCL_TX_FILTER_MINIFY_NEAREST 0x00010000 -#define NV20TCL_TX_FILTER_MINIFY_LINEAR 0x00020000 -#define NV20TCL_TX_FILTER_MINIFY_NEAREST_MIPMAP_NEAREST 0x00030000 -#define NV20TCL_TX_FILTER_MINIFY_LINEAR_MIPMAP_NEAREST 0x00040000 -#define NV20TCL_TX_FILTER_MINIFY_NEAREST_MIPMAP_LINEAR 0x00050000 -#define NV20TCL_TX_FILTER_MINIFY_LINEAR_MIPMAP_LINEAR 0x00060000 -#define NV20TCL_TX_FILTER_MAGNIFY_SHIFT 24 -#define NV20TCL_TX_FILTER_MAGNIFY_MASK 0x0f000000 -#define NV20TCL_TX_FILTER_MAGNIFY_NEAREST 0x01000000 -#define NV20TCL_TX_FILTER_MAGNIFY_LINEAR 0x02000000 -#define NV20TCL_TX_NPOT_SIZE(x) (0x00001b1c+((x)*64)) -#define NV20TCL_TX_NPOT_SIZE__SIZE 0x00000004 -#define NV20TCL_TX_NPOT_SIZE_H_SHIFT 0 -#define NV20TCL_TX_NPOT_SIZE_H_MASK 0x0000ffff -#define NV20TCL_TX_NPOT_SIZE_W_SHIFT 16 -#define NV20TCL_TX_NPOT_SIZE_W_MASK 0xffff0000 -#define NV20TCL_TX_PALETTE_OFFSET(x) (0x00001b20+((x)*64)) -#define NV20TCL_TX_PALETTE_OFFSET__SIZE 0x00000004 -#define NV20TCL_TX_BORDER_COLOR(x) (0x00001b24+((x)*64)) -#define NV20TCL_TX_BORDER_COLOR__SIZE 0x00000004 -#define NV20TCL_TX_BORDER_COLOR_B_SHIFT 0 -#define NV20TCL_TX_BORDER_COLOR_B_MASK 0x000000ff -#define NV20TCL_TX_BORDER_COLOR_G_SHIFT 8 -#define NV20TCL_TX_BORDER_COLOR_G_MASK 0x0000ff00 -#define NV20TCL_TX_BORDER_COLOR_R_SHIFT 16 -#define NV20TCL_TX_BORDER_COLOR_R_MASK 0x00ff0000 -#define NV20TCL_TX_BORDER_COLOR_A_SHIFT 24 -#define NV20TCL_TX_BORDER_COLOR_A_MASK 0xff000000 -#define NV20TCL_TX_SHADER_OFFSET_MATRIX00(x) (0x00001b28+((x)*64)) -#define NV20TCL_TX_SHADER_OFFSET_MATRIX00__SIZE 0x00000004 -#define NV20TCL_TX_SHADER_OFFSET_MATRIX01(x) (0x00001b2c+((x)*64)) -#define NV20TCL_TX_SHADER_OFFSET_MATRIX01__SIZE 0x00000004 -#define NV20TCL_TX_SHADER_OFFSET_MATRIX11(x) (0x00001b30+((x)*64)) -#define NV20TCL_TX_SHADER_OFFSET_MATRIX11__SIZE 0x00000004 -#define NV20TCL_TX_SHADER_OFFSET_MATRIX10(x) (0x00001b34+((x)*64)) -#define NV20TCL_TX_SHADER_OFFSET_MATRIX10__SIZE 0x00000004 -#define NV20TCL_DEPTH_UNK17D8 0x00001d78 -#define NV20TCL_DEPTH_UNK17D8_CLAMP_SHIFT 4 -#define NV20TCL_DEPTH_UNK17D8_CLAMP_MASK 0x000000f0 -#define NV20TCL_MULTISAMPLE_CONTROL 0x00001d7c -#define NV20TCL_CLEAR_DEPTH_VALUE 0x00001d8c -#define NV20TCL_CLEAR_VALUE 0x00001d90 -#define NV20TCL_CLEAR_BUFFERS 0x00001d94 -#define NV20TCL_CLEAR_BUFFERS_COLOR_A (1 << 7) -#define NV20TCL_CLEAR_BUFFERS_COLOR_B (1 << 6) -#define NV20TCL_CLEAR_BUFFERS_COLOR_G (1 << 5) -#define NV20TCL_CLEAR_BUFFERS_COLOR_R (1 << 4) -#define NV20TCL_CLEAR_BUFFERS_STENCIL (1 << 1) -#define NV20TCL_CLEAR_BUFFERS_DEPTH (1 << 0) -#define NV20TCL_RC_COLOR0 0x00001e20 -#define NV20TCL_RC_COLOR0_B_SHIFT 0 -#define NV20TCL_RC_COLOR0_B_MASK 0x000000ff -#define NV20TCL_RC_COLOR0_G_SHIFT 8 -#define NV20TCL_RC_COLOR0_G_MASK 0x0000ff00 -#define NV20TCL_RC_COLOR0_R_SHIFT 16 -#define NV20TCL_RC_COLOR0_R_MASK 0x00ff0000 -#define NV20TCL_RC_COLOR0_A_SHIFT 24 -#define NV20TCL_RC_COLOR0_A_MASK 0xff000000 -#define NV20TCL_RC_COLOR1 0x00001e24 -#define NV20TCL_RC_COLOR1_B_SHIFT 0 -#define NV20TCL_RC_COLOR1_B_MASK 0x000000ff -#define NV20TCL_RC_COLOR1_G_SHIFT 8 -#define NV20TCL_RC_COLOR1_G_MASK 0x0000ff00 -#define NV20TCL_RC_COLOR1_R_SHIFT 16 -#define NV20TCL_RC_COLOR1_R_MASK 0x00ff0000 -#define NV20TCL_RC_COLOR1_A_SHIFT 24 -#define NV20TCL_RC_COLOR1_A_MASK 0xff000000 -#define NV20TCL_BACK_MATERIAL_SHININESS(x) (0x00001e28+((x)*4)) -#define NV20TCL_BACK_MATERIAL_SHININESS__SIZE 0x00000006 -#define NV20TCL_RC_OUT_RGB(x) (0x00001e40+((x)*4)) -#define NV20TCL_RC_OUT_RGB__SIZE 0x00000008 -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_SHIFT 0 -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_MASK 0x0000000f -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_ZERO 0x00000000 -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_CONSTANT_COLOR0 0x00000001 -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_CONSTANT_COLOR1 0x00000002 -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_FOG 0x00000003 -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_PRIMARY_COLOR 0x00000004 -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_SECONDARY_COLOR 0x00000005 -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE0 0x00000008 -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE1 0x00000009 -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_SPARE0 0x0000000c -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_SPARE1 0x0000000d -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_E_TIMES_F 0x0000000f -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE2 0x0000000a -#define NV20TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE3 0x0000000b -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_SHIFT 4 -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_MASK 0x000000f0 -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_ZERO 0x00000000 -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_CONSTANT_COLOR0 0x00000010 -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_CONSTANT_COLOR1 0x00000020 -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_FOG 0x00000030 -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_PRIMARY_COLOR 0x00000040 -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_SECONDARY_COLOR 0x00000050 -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE0 0x00000080 -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE1 0x00000090 -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_SPARE0 0x000000c0 -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_SPARE1 0x000000d0 -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000000e0 -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_E_TIMES_F 0x000000f0 -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE2 0x000000a0 -#define NV20TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE3 0x000000b0 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_SHIFT 8 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_MASK 0x00000f00 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_ZERO 0x00000000 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_CONSTANT_COLOR0 0x00000100 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_CONSTANT_COLOR1 0x00000200 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_FOG 0x00000300 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_PRIMARY_COLOR 0x00000400 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_SECONDARY_COLOR 0x00000500 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE0 0x00000800 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE1 0x00000900 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE0 0x00000c00 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE1 0x00000d00 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_E_TIMES_F 0x00000f00 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE2 0x00000a00 -#define NV20TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE3 0x00000b00 -#define NV20TCL_RC_OUT_RGB_CD_DOT_PRODUCT (1 << 12) -#define NV20TCL_RC_OUT_RGB_AB_DOT_PRODUCT (1 << 13) -#define NV20TCL_RC_OUT_RGB_MUX_SUM (1 << 14) -#define NV20TCL_RC_OUT_RGB_BIAS (1 << 15) -#define NV20TCL_RC_OUT_RGB_BIAS_NONE 0x00000000 -#define NV20TCL_RC_OUT_RGB_BIAS_BIAS_BY_NEGATIVE_ONE_HALF 0x00008000 -#define NV20TCL_RC_OUT_RGB_SCALE_SHIFT 16 -#define NV20TCL_RC_OUT_RGB_SCALE_MASK 0x00030000 -#define NV20TCL_RC_OUT_RGB_SCALE_NONE 0x00000000 -#define NV20TCL_RC_OUT_RGB_SCALE_SCALE_BY_TWO 0x00010000 -#define NV20TCL_RC_OUT_RGB_SCALE_SCALE_BY_FOUR 0x00020000 -#define NV20TCL_RC_OUT_RGB_SCALE_SCALE_BY_ONE_HALF 0x00030000 -#define NV20TCL_RC_ENABLE 0x00001e60 -#define NV20TCL_RC_ENABLE_NUM_COMBINERS_SHIFT 0 -#define NV20TCL_RC_ENABLE_NUM_COMBINERS_MASK 0x0000000f -#define NV20TCL_TX_RCOMP 0x00001e6c -#define NV20TCL_TX_RCOMP_NEVER 0x00000000 -#define NV20TCL_TX_RCOMP_GREATER 0x00000001 -#define NV20TCL_TX_RCOMP_EQUAL 0x00000002 -#define NV20TCL_TX_RCOMP_GEQUAL 0x00000003 -#define NV20TCL_TX_RCOMP_LESS 0x00000004 -#define NV20TCL_TX_RCOMP_NOTEQUAL 0x00000005 -#define NV20TCL_TX_RCOMP_LEQUAL 0x00000006 -#define NV20TCL_TX_RCOMP_ALWAYS 0x00000007 -#define NV20TCL_TX_SHADER_OP 0x00001e70 -#define NV20TCL_TX_SHADER_OP_TX0_SHIFT 0 -#define NV20TCL_TX_SHADER_OP_TX0_MASK 0x0000001f -#define NV20TCL_TX_SHADER_OP_TX0_NONE 0x00000000 -#define NV20TCL_TX_SHADER_OP_TX0_TEXTURE_2D 0x00000001 -#define NV20TCL_TX_SHADER_OP_TX0_PASS_THROUGH 0x00000004 -#define NV20TCL_TX_SHADER_OP_TX0_CULL_FRAGMENT 0x00000005 -#define NV20TCL_TX_SHADER_OP_TX0_OFFSET_TEXTURE_2D 0x00000006 -#define NV20TCL_TX_SHADER_OP_TX0_DOT_PRODUCT_TEXTURE_2D 0x00000009 -#define NV20TCL_TX_SHADER_OP_TX0_DOT_PRODUCT_DEPTH_REPLACE 0x0000000a -#define NV20TCL_TX_SHADER_OP_TX0_DEPENDANT_AR_TEXTURE_2D 0x0000000f -#define NV20TCL_TX_SHADER_OP_TX0_DEPENDANT_GB_TEXTURE_2D 0x00000010 -#define NV20TCL_TX_SHADER_OP_TX0_DOT_PRODUCT 0x00000011 -#define NV20TCL_TX_SHADER_OP_TX1_SHIFT 5 -#define NV20TCL_TX_SHADER_OP_TX1_MASK 0x000003e0 -#define NV20TCL_TX_SHADER_OP_TX1_NONE 0x00000000 -#define NV20TCL_TX_SHADER_OP_TX1_TEXTURE_2D 0x00000020 -#define NV20TCL_TX_SHADER_OP_TX1_PASS_THROUGH 0x00000080 -#define NV20TCL_TX_SHADER_OP_TX1_CULL_FRAGMENT 0x000000a0 -#define NV20TCL_TX_SHADER_OP_TX1_OFFSET_TEXTURE_2D 0x000000c0 -#define NV20TCL_TX_SHADER_OP_TX1_DOT_PRODUCT_TEXTURE_2D 0x00000120 -#define NV20TCL_TX_SHADER_OP_TX1_DOT_PRODUCT_DEPTH_REPLACE 0x00000140 -#define NV20TCL_TX_SHADER_OP_TX1_DEPENDANT_AR_TEXTURE_2D 0x000001e0 -#define NV20TCL_TX_SHADER_OP_TX1_DEPENDANT_GB_TEXTURE_2D 0x00000200 -#define NV20TCL_TX_SHADER_OP_TX1_DOT_PRODUCT 0x00000220 -#define NV20TCL_TX_SHADER_OP_TX2_SHIFT 10 -#define NV20TCL_TX_SHADER_OP_TX2_MASK 0x00007c00 -#define NV20TCL_TX_SHADER_OP_TX2_NONE 0x00000000 -#define NV20TCL_TX_SHADER_OP_TX2_TEXTURE_2D 0x00000400 -#define NV20TCL_TX_SHADER_OP_TX2_PASS_THROUGH 0x00001000 -#define NV20TCL_TX_SHADER_OP_TX2_CULL_FRAGMENT 0x00001400 -#define NV20TCL_TX_SHADER_OP_TX2_OFFSET_TEXTURE_2D 0x00001800 -#define NV20TCL_TX_SHADER_OP_TX2_DOT_PRODUCT_TEXTURE_2D 0x00002400 -#define NV20TCL_TX_SHADER_OP_TX2_DOT_PRODUCT_DEPTH_REPLACE 0x00002800 -#define NV20TCL_TX_SHADER_OP_TX2_DEPENDANT_AR_TEXTURE_2D 0x00003c00 -#define NV20TCL_TX_SHADER_OP_TX2_DEPENDANT_GB_TEXTURE_2D 0x00004000 -#define NV20TCL_TX_SHADER_OP_TX2_DOT_PRODUCT 0x00004400 -#define NV20TCL_TX_SHADER_OP_TX3_SHIFT 15 -#define NV20TCL_TX_SHADER_OP_TX3_MASK 0x000f8000 -#define NV20TCL_TX_SHADER_OP_TX3_NONE 0x00000000 -#define NV20TCL_TX_SHADER_OP_TX3_TEXTURE_2D 0x00008000 -#define NV20TCL_TX_SHADER_OP_TX3_PASS_THROUGH 0x00020000 -#define NV20TCL_TX_SHADER_OP_TX3_CULL_FRAGMENT 0x00028000 -#define NV20TCL_TX_SHADER_OP_TX3_OFFSET_TEXTURE_2D 0x00030000 -#define NV20TCL_TX_SHADER_OP_TX3_DOT_PRODUCT_TEXTURE_2D 0x00048000 -#define NV20TCL_TX_SHADER_OP_TX3_DOT_PRODUCT_DEPTH_REPLACE 0x00050000 -#define NV20TCL_TX_SHADER_OP_TX3_DEPENDANT_AR_TEXTURE_2D 0x00078000 -#define NV20TCL_TX_SHADER_OP_TX3_DEPENDANT_GB_TEXTURE_2D 0x00080000 -#define NV20TCL_TX_SHADER_OP_TX3_DOT_PRODUCT 0x00088000 -#define NV20TCL_TX_SHADER_DOTMAPPING 0x00001e74 -#define NV20TCL_TX_SHADER_DOTMAPPING_TX0_SHIFT 0 -#define NV20TCL_TX_SHADER_DOTMAPPING_TX0_MASK 0x0000000f -#define NV20TCL_TX_SHADER_DOTMAPPING_TX1_SHIFT 4 -#define NV20TCL_TX_SHADER_DOTMAPPING_TX1_MASK 0x000000f0 -#define NV20TCL_TX_SHADER_DOTMAPPING_TX2_SHIFT 8 -#define NV20TCL_TX_SHADER_DOTMAPPING_TX2_MASK 0x00000f00 -#define NV20TCL_TX_SHADER_DOTMAPPING_TX3_SHIFT 12 -#define NV20TCL_TX_SHADER_DOTMAPPING_TX3_MASK 0x0000f000 -#define NV20TCL_TX_SHADER_PREVIOUS 0x00001e78 -#define NV20TCL_TX_SHADER_PREVIOUS_TX0_SHIFT 8 -#define NV20TCL_TX_SHADER_PREVIOUS_TX0_MASK 0x00000f00 -#define NV20TCL_TX_SHADER_PREVIOUS_TX1_SHIFT 12 -#define NV20TCL_TX_SHADER_PREVIOUS_TX1_MASK 0x0000f000 -#define NV20TCL_TX_SHADER_PREVIOUS_TX2_SHIFT 16 -#define NV20TCL_TX_SHADER_PREVIOUS_TX2_MASK 0x00030000 -#define NV20TCL_TX_SHADER_PREVIOUS_TX3_SHIFT 20 -#define NV20TCL_TX_SHADER_PREVIOUS_TX3_MASK 0x00300000 -#define NV20TCL_ENGINE 0x00001e94 -#define NV20TCL_ENGINE_VP (1 << 1) -#define NV20TCL_ENGINE_FIXED (1 << 2) -#define NV20TCL_VP_UPLOAD_FROM_ID 0x00001e9c -#define NV20TCL_VP_START_FROM_ID 0x00001ea0 -#define NV20TCL_VP_UPLOAD_CONST_ID 0x00001ea4 - - -#define NV25TCL 0x00000597 - -#define NV25TCL_DMA_IN_MEMORY4 0x0000019c -#define NV25TCL_DMA_IN_MEMORY5 0x000001a0 -#define NV25TCL_DMA_IN_MEMORY8 0x000001ac -#define NV25TCL_DMA_IN_MEMORY9 0x000001b0 - -#endif /* NOUVEAU_REG_H */ - diff --git a/src/mesa/drivers/dri/nouveau/nouveau_context.c b/src/mesa/drivers/dri/nouveau/nouveau_context.c index 0ace139b88..53a121420d 100644 --- a/src/mesa/drivers/dri/nouveau/nouveau_context.c +++ b/src/mesa/drivers/dri/nouveau/nouveau_context.c @@ -119,6 +119,7 @@ nouveau_context_init(struct gl_context *ctx, struct nouveau_screen *screen, nouveau_state_init(ctx); nouveau_bo_state_init(ctx); + nouveau_scratch_init(ctx); _mesa_meta_init(ctx); _swrast_CreateContext(ctx); _vbo_CreateContext(ctx); @@ -163,6 +164,7 @@ nouveau_context_deinit(struct gl_context *ctx) if (nctx->hw.chan) nouveau_channel_free(&nctx->hw.chan); + nouveau_scratch_destroy(ctx); nouveau_bo_state_destroy(ctx); _mesa_free_context_data(ctx); } @@ -312,7 +314,7 @@ nouveau_context_make_current(__DRIcontext *dri_ctx, __DRIdrawable *dri_draw, GLboolean nouveau_context_unbind(__DRIcontext *dri_ctx) { - /* Unset current context and dispath table */ + /* Unset current context and dispatch table */ _mesa_make_current(NULL, NULL, NULL); return GL_TRUE; @@ -325,10 +327,12 @@ nouveau_fallback(struct gl_context *ctx, enum nouveau_fallback mode) nctx->fallback = MAX2(HWTNL, mode); - if (mode < SWRAST) + if (mode < SWRAST) { nouveau_state_emit(ctx); - else + nouveau_bo_state_emit(ctx); + } else { FIRE_RING(context_chan(ctx)); + } } static void @@ -365,5 +369,6 @@ nouveau_validate_framebuffer(struct gl_context *ctx) validate_framebuffer(dri_ctx, dri_read, &dri_ctx->dri2.read_stamp); - nouveau_state_emit(ctx); + if (ctx->NewState & _NEW_BUFFERS) + _mesa_update_state(ctx); } diff --git a/src/mesa/drivers/dri/nouveau/nouveau_context.h b/src/mesa/drivers/dri/nouveau/nouveau_context.h index 23a8725672..7ebc676379 100644 --- a/src/mesa/drivers/dri/nouveau/nouveau_context.h +++ b/src/mesa/drivers/dri/nouveau/nouveau_context.h @@ -30,6 +30,7 @@ #include "nouveau_screen.h" #include "nouveau_state.h" #include "nouveau_bo_state.h" +#include "nouveau_scratch.h" #include "nouveau_render.h" #include "main/bitset.h" @@ -67,6 +68,7 @@ struct nouveau_context { struct nouveau_hw_state hw; struct nouveau_bo_state bo; struct nouveau_render_state render; + struct nouveau_scratch_state scratch; struct { GLboolean clear_blocked; diff --git a/src/mesa/drivers/dri/nouveau/nouveau_render.h b/src/mesa/drivers/dri/nouveau/nouveau_render.h index 81c6119fcc..0539c37758 100644 --- a/src/mesa/drivers/dri/nouveau/nouveau_render.h +++ b/src/mesa/drivers/dri/nouveau/nouveau_render.h @@ -28,46 +28,22 @@ #define __NOUVEAU_RENDER_H__ #include "vbo/vbo_context.h" - -struct nouveau_array_state; +#include "nouveau_array.h" typedef void (*dispatch_t)(struct gl_context *, unsigned int, int, unsigned int); -typedef unsigned (*extract_u_t)(struct nouveau_array_state *, int, int); -typedef float (*extract_f_t)(struct nouveau_array_state *, int, int); +typedef void (*emit_t)(struct gl_context *, struct nouveau_array *, const void *); struct nouveau_attr_info { int vbo_index; int imm_method; int imm_fields; - void (*emit)(struct gl_context *, struct nouveau_array_state *, const void *); -}; - -struct nouveau_array_state { - int attr; - int stride, fields, type; - - struct nouveau_bo *bo; - unsigned offset; - const void *buf; - - extract_u_t extract_u; - extract_f_t extract_f; -}; - -#define RENDER_SCRATCH_COUNT 2 -#define RENDER_SCRATCH_SIZE 2*1024*1024 - -struct nouveau_scratch_state { - struct nouveau_bo *bo[RENDER_SCRATCH_COUNT]; - - int index; - int offset; - void *buf; + emit_t emit; }; struct nouveau_swtnl_state { struct nouveau_bo *vbo; + unsigned offset; void *buf; unsigned vertex_count; GLenum primitive; @@ -79,8 +55,8 @@ struct nouveau_render_state { IMM } mode; - struct nouveau_array_state ib; - struct nouveau_array_state attrs[VERT_ATTRIB_MAX]; + struct nouveau_array ib; + struct nouveau_array attrs[VERT_ATTRIB_MAX]; /* Maps a HW VBO index or IMM emission order to an index in * the attrs array above (or -1 if unused). */ @@ -89,10 +65,16 @@ struct nouveau_render_state { int attr_count; int vertex_size; - struct nouveau_scratch_state scratch; struct nouveau_swtnl_state swtnl; }; #define to_render_state(ctx) (&to_nouveau_context(ctx)->render) +#define FOR_EACH_ATTR(render, i, attr) \ + for (i = 0; attr = (render)->map[i], i < NUM_VERTEX_ATTRS; i++) + +#define FOR_EACH_BOUND_ATTR(render, i, attr) \ + for (i = 0; attr = (render)->map[i], i < render->attr_count; i++) \ + if (attr >= 0) + #endif diff --git a/src/mesa/drivers/dri/nouveau/nouveau_render_t.c b/src/mesa/drivers/dri/nouveau/nouveau_render_t.c index dd38c14aa7..e0cf727d11 100644 --- a/src/mesa/drivers/dri/nouveau/nouveau_render_t.c +++ b/src/mesa/drivers/dri/nouveau/nouveau_render_t.c @@ -100,8 +100,8 @@ /* * Select an appropriate dispatch function for the given index buffer. */ -static void -get_array_dispatch(struct nouveau_array_state *a, dispatch_t *dispatch) +static dispatch_t +get_array_dispatch(struct nouveau_array *a) { if (!a->fields) { auto void f(struct gl_context *, unsigned int, int, unsigned int); @@ -114,7 +114,7 @@ get_array_dispatch(struct nouveau_array_state *a, dispatch_t *dispatch) EMIT_VBO(L, ctx, start, delta, n); }; - *dispatch = f; + return f; } else if (a->type == GL_UNSIGNED_INT) { auto void f(struct gl_context *, unsigned int, int, unsigned int); @@ -127,7 +127,7 @@ get_array_dispatch(struct nouveau_array_state *a, dispatch_t *dispatch) EMIT_VBO(I32, ctx, start, delta, n); }; - *dispatch = f; + return f; } else { auto void f(struct gl_context *, unsigned int, int, unsigned int); @@ -141,115 +141,11 @@ get_array_dispatch(struct nouveau_array_state *a, dispatch_t *dispatch) EMIT_VBO(I16, ctx, start, delta, n & ~1); }; - *dispatch = f; + return f; } } /* - * Select appropriate element extraction functions for the given - * array. - */ -static void -get_array_extract(struct nouveau_array_state *a, - extract_u_t *extract_u, extract_f_t *extract_f) -{ -#define EXTRACT(in_t, out_t, k) \ - ({ \ - auto out_t f(struct nouveau_array_state *, int, int); \ - out_t f(struct nouveau_array_state *a, int i, int j) { \ - in_t x = ((in_t *)(a->buf + i * a->stride))[j]; \ - \ - return (out_t)x / (k); \ - }; \ - f; \ - }); - - switch (a->type) { - case GL_BYTE: - *extract_u = EXTRACT(char, unsigned, 1); - *extract_f = EXTRACT(char, float, SCHAR_MAX); - break; - case GL_UNSIGNED_BYTE: - *extract_u = EXTRACT(unsigned char, unsigned, 1); - *extract_f = EXTRACT(unsigned char, float, UCHAR_MAX); - break; - case GL_SHORT: - *extract_u = EXTRACT(short, unsigned, 1); - *extract_f = EXTRACT(short, float, SHRT_MAX); - break; - case GL_UNSIGNED_SHORT: - *extract_u = EXTRACT(unsigned short, unsigned, 1); - *extract_f = EXTRACT(unsigned short, float, USHRT_MAX); - break; - case GL_INT: - *extract_u = EXTRACT(int, unsigned, 1); - *extract_f = EXTRACT(int, float, INT_MAX); - break; - case GL_UNSIGNED_INT: - *extract_u = EXTRACT(unsigned int, unsigned, 1); - *extract_f = EXTRACT(unsigned int, float, UINT_MAX); - break; - case GL_FLOAT: - *extract_u = EXTRACT(float, unsigned, 1.0 / UINT_MAX); - *extract_f = EXTRACT(float, float, 1); - break; - - default: - assert(0); - } -} - -/* - * Returns a pointer to a chunk of <size> bytes long GART memory. <bo> - * will be updated with the buffer object the memory is located in. - * - * If <offset> is provided, it will be updated with the offset within - * <bo> of the allocated memory. Otherwise the returned memory will - * always be located right at the beginning of <bo>. - */ -static inline void * -get_scratch_vbo(struct gl_context *ctx, unsigned size, struct nouveau_bo **bo, - unsigned *offset) -{ - struct nouveau_scratch_state *scratch = &to_render_state(ctx)->scratch; - void *buf; - - if (scratch->buf && offset && - size <= RENDER_SCRATCH_SIZE - scratch->offset) { - nouveau_bo_ref(scratch->bo[scratch->index], bo); - - buf = scratch->buf + scratch->offset; - *offset = scratch->offset; - scratch->offset += size; - - } else if (size <= RENDER_SCRATCH_SIZE) { - scratch->index = (scratch->index + 1) % RENDER_SCRATCH_COUNT; - nouveau_bo_ref(scratch->bo[scratch->index], bo); - - nouveau_bo_map(*bo, NOUVEAU_BO_WR); - buf = scratch->buf = (*bo)->map; - nouveau_bo_unmap(*bo); - - if (offset) - *offset = 0; - scratch->offset = size; - - } else { - nouveau_bo_new(context_dev(ctx), - NOUVEAU_BO_MAP | NOUVEAU_BO_GART, 0, size, bo); - - nouveau_bo_map(*bo, NOUVEAU_BO_WR); - buf = (*bo)->map; - nouveau_bo_unmap(*bo); - - if (offset) - *offset = 0; - } - - return buf; -} - -/* * Returns how many vertices you can draw using <n> pushbuf dwords. */ static inline unsigned @@ -277,6 +173,11 @@ get_max_vertices(struct gl_context *ctx, const struct _mesa_index_buffer *ib, case GL_UNSIGNED_BYTE: max_out = MAX_OUT_I16; break; + + default: + assert(0); + max_out = 0; + break; } } else { max_out = MAX_OUT_L; @@ -286,76 +187,26 @@ get_max_vertices(struct gl_context *ctx, const struct _mesa_index_buffer *ib, } } -#include "nouveau_vbo_t.c" -#include "nouveau_swtnl_t.c" - static void -TAG(emit_material)(struct gl_context *ctx, struct nouveau_array_state *a, +TAG(emit_material)(struct gl_context *ctx, struct nouveau_array *a, const void *v) { - const int attr = a->attr - VERT_ATTRIB_GENERIC0; - const int state = ((int []) { - NOUVEAU_STATE_MATERIAL_FRONT_AMBIENT, - NOUVEAU_STATE_MATERIAL_BACK_AMBIENT, - NOUVEAU_STATE_MATERIAL_FRONT_DIFFUSE, - NOUVEAU_STATE_MATERIAL_BACK_DIFFUSE, - NOUVEAU_STATE_MATERIAL_FRONT_SPECULAR, - NOUVEAU_STATE_MATERIAL_BACK_SPECULAR, - NOUVEAU_STATE_MATERIAL_FRONT_AMBIENT, - NOUVEAU_STATE_MATERIAL_BACK_AMBIENT, - NOUVEAU_STATE_MATERIAL_FRONT_SHININESS, - NOUVEAU_STATE_MATERIAL_BACK_SHININESS - }) [attr]; + int attr = a->attr - VERT_ATTRIB_GENERIC0; + int state = ((int []) { + NOUVEAU_STATE_MATERIAL_FRONT_AMBIENT, + NOUVEAU_STATE_MATERIAL_BACK_AMBIENT, + NOUVEAU_STATE_MATERIAL_FRONT_DIFFUSE, + NOUVEAU_STATE_MATERIAL_BACK_DIFFUSE, + NOUVEAU_STATE_MATERIAL_FRONT_SPECULAR, + NOUVEAU_STATE_MATERIAL_BACK_SPECULAR, + NOUVEAU_STATE_MATERIAL_FRONT_AMBIENT, + NOUVEAU_STATE_MATERIAL_BACK_AMBIENT, + NOUVEAU_STATE_MATERIAL_FRONT_SHININESS, + NOUVEAU_STATE_MATERIAL_BACK_SHININESS + }) [attr]; COPY_4V(ctx->Light.Material.Attrib[attr], (float *)v); _mesa_update_material(ctx, 1 << attr); context_drv(ctx)->emit[state](ctx, state); } - -static void -TAG(render_prims)(struct gl_context *ctx, const struct gl_client_array **arrays, - const struct _mesa_prim *prims, GLuint nr_prims, - const struct _mesa_index_buffer *ib, - GLboolean index_bounds_valid, - GLuint min_index, GLuint max_index) -{ - struct nouveau_context *nctx = to_nouveau_context(ctx); - - nouveau_validate_framebuffer(ctx); - - if (nctx->fallback == HWTNL) - TAG(vbo_render_prims)(ctx, arrays, prims, nr_prims, ib, - index_bounds_valid, min_index, max_index); - - if (nctx->fallback == SWTNL) - _tnl_vbo_draw_prims(ctx, arrays, prims, nr_prims, ib, - index_bounds_valid, min_index, max_index); -} - -void -TAG(render_init)(struct gl_context *ctx) -{ - struct nouveau_render_state *render = to_render_state(ctx); - struct nouveau_scratch_state *scratch = &render->scratch; - int ret, i; - - for (i = 0; i < RENDER_SCRATCH_COUNT; i++) { - ret = nouveau_bo_new(context_dev(ctx), - NOUVEAU_BO_MAP | NOUVEAU_BO_GART, - 0, RENDER_SCRATCH_SIZE, &scratch->bo[i]); - assert(!ret); - } - - for (i = 0; i < VERT_ATTRIB_MAX; i++) - render->map[i] = -1; - - TAG(swtnl_init)(ctx); - vbo_set_draw_func(ctx, TAG(render_prims)); -} - -void -TAG(render_destroy)(struct gl_context *ctx) -{ - TAG(swtnl_destroy)(ctx); -} diff --git a/src/mesa/drivers/dri/nouveau/nouveau_scratch.c b/src/mesa/drivers/dri/nouveau/nouveau_scratch.c new file mode 100644 index 0000000000..ddda67b2f1 --- /dev/null +++ b/src/mesa/drivers/dri/nouveau/nouveau_scratch.c @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2009-2010 Francisco Jerez. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ + +#include "nouveau_driver.h" +#include "nouveau_context.h" + +/* + * Returns a pointer to a chunk of 'size' bytes long GART memory. 'bo' + * and 'offset' will point to the returned memory. + */ +void * +nouveau_get_scratch(struct gl_context *ctx, unsigned size, + struct nouveau_bo **bo, unsigned *offset) +{ + struct nouveau_scratch_state *scratch = + &to_nouveau_context(ctx)->scratch; + void *buf; + + if (scratch->buf && size <= NOUVEAU_SCRATCH_SIZE - scratch->offset) { + nouveau_bo_ref(scratch->bo[scratch->index], bo); + + buf = scratch->buf + scratch->offset; + *offset = scratch->offset; + scratch->offset += size; + + } else if (size <= NOUVEAU_SCRATCH_SIZE) { + scratch->index = (scratch->index + 1) % NOUVEAU_SCRATCH_COUNT; + nouveau_bo_ref(scratch->bo[scratch->index], bo); + + nouveau_bo_map(*bo, NOUVEAU_BO_WR); + buf = scratch->buf = (*bo)->map; + nouveau_bo_unmap(*bo); + + *offset = 0; + scratch->offset = size; + + } else { + nouveau_bo_new(context_dev(ctx), + NOUVEAU_BO_MAP | NOUVEAU_BO_GART, 0, size, bo); + + nouveau_bo_map(*bo, NOUVEAU_BO_WR); + buf = (*bo)->map; + nouveau_bo_unmap(*bo); + + *offset = 0; + } + + return buf; +} + +void +nouveau_scratch_init(struct gl_context *ctx) +{ + struct nouveau_scratch_state *scratch = + &to_nouveau_context(ctx)->scratch; + int ret, i; + + for (i = 0; i < NOUVEAU_SCRATCH_COUNT; i++) { + ret = nouveau_bo_new(context_dev(ctx), + NOUVEAU_BO_MAP | NOUVEAU_BO_GART, + 0, NOUVEAU_SCRATCH_SIZE, &scratch->bo[i]); + assert(!ret); + } +} + +void +nouveau_scratch_destroy(struct gl_context *ctx) +{ + struct nouveau_scratch_state *scratch = + &to_nouveau_context(ctx)->scratch; + int i; + + for (i = 0; i < NOUVEAU_SCRATCH_COUNT; i++) + nouveau_bo_ref(NULL, &scratch->bo[i]); +} diff --git a/src/mesa/drivers/dri/nouveau/nouveau_scratch.h b/src/mesa/drivers/dri/nouveau/nouveau_scratch.h new file mode 100644 index 0000000000..b60b33dd1a --- /dev/null +++ b/src/mesa/drivers/dri/nouveau/nouveau_scratch.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2009-2010 Francisco Jerez. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ + +#ifndef __NOUVEAU_SCRATCH_H__ +#define __NOUVEAU_SCRATCH_H__ + +#define NOUVEAU_SCRATCH_COUNT 2 +#define NOUVEAU_SCRATCH_SIZE 3*1024*1024 + +struct nouveau_scratch_state { + struct nouveau_bo *bo[NOUVEAU_SCRATCH_COUNT]; + + int index; + int offset; + void *buf; +}; + +void * +nouveau_get_scratch(struct gl_context *ctx, unsigned size, + struct nouveau_bo **bo, unsigned *offset); + +void +nouveau_scratch_init(struct gl_context *ctx); + +void +nouveau_scratch_destroy(struct gl_context *ctx); + +#endif diff --git a/src/mesa/drivers/dri/nouveau/nouveau_state.c b/src/mesa/drivers/dri/nouveau/nouveau_state.c index 7b7ddd2f54..1579d29efc 100644 --- a/src/mesa/drivers/dri/nouveau/nouveau_state.c +++ b/src/mesa/drivers/dri/nouveau/nouveau_state.c @@ -113,6 +113,12 @@ nouveau_depth_range(struct gl_context *ctx, GLclampd nearval, GLclampd farval) } static void +nouveau_read_buffer(struct gl_context *ctx, GLenum buffer) +{ + nouveau_validate_framebuffer(ctx); +} + +static void nouveau_draw_buffers(struct gl_context *ctx, GLsizei n, const GLenum *buffers) { nouveau_validate_framebuffer(ctx); @@ -512,6 +518,7 @@ nouveau_state_init(struct gl_context *ctx) ctx->Driver.DepthFunc = nouveau_depth_func; ctx->Driver.DepthMask = nouveau_depth_mask; ctx->Driver.DepthRange = nouveau_depth_range; + ctx->Driver.ReadBuffer = nouveau_read_buffer; ctx->Driver.DrawBuffers = nouveau_draw_buffers; ctx->Driver.Enable = nouveau_enable; ctx->Driver.Fogfv = nouveau_fog; diff --git a/src/mesa/drivers/dri/nouveau/nouveau_swtnl_t.c b/src/mesa/drivers/dri/nouveau/nouveau_swtnl_t.c index b3588e8fd3..f084f89d29 100644 --- a/src/mesa/drivers/dri/nouveau/nouveau_swtnl_t.c +++ b/src/mesa/drivers/dri/nouveau/nouveau_swtnl_t.c @@ -28,6 +28,8 @@ #include "tnl/t_pipeline.h" #include "tnl/t_vertex.h" +#define SWTNL_VBO_SIZE 65536 + static enum tnl_attr_format swtnl_get_format(int type, int fields) { switch (type) { @@ -105,7 +107,7 @@ swtnl_choose_attrs(struct gl_context *ctx) TNLcontext *tnl = TNL_CONTEXT(ctx); struct tnl_clipspace *vtx = &tnl->clipspace; static struct tnl_attr_map map[NUM_VERTEX_ATTRS]; - int fields, i, n = 0; + int fields, attr, i, n = 0; render->mode = VBO; render->attr_count = NUM_VERTEX_ATTRS; @@ -116,7 +118,7 @@ swtnl_choose_attrs(struct gl_context *ctx) for (i = 0; i < VERT_ATTRIB_MAX; i++) { struct nouveau_attr_info *ha = &TAG(vertex_attrs)[i]; struct swtnl_attr_info *sa = &swtnl_attrs[i]; - struct nouveau_array_state *a = &render->attrs[i]; + struct nouveau_array *a = &render->attrs[i]; if (!sa->fields) continue; /* Unsupported attribute. */ @@ -141,13 +143,8 @@ swtnl_choose_attrs(struct gl_context *ctx) _tnl_install_attrs(ctx, map, n, NULL, 0); - for (i = 0; i < vtx->attr_count; i++) { - struct tnl_clipspace_attr *ta = &vtx->attr[i]; - struct nouveau_array_state *a = &render->attrs[ta->attrib]; - - a->stride = vtx->vertex_size; - a->offset = ta->vertoffset; - } + FOR_EACH_BOUND_ATTR(render, i, attr) + render->attrs[attr].stride = vtx->vertex_size; TAG(render_set_format)(ctx); } @@ -158,8 +155,8 @@ swtnl_alloc_vertices(struct gl_context *ctx) struct nouveau_swtnl_state *swtnl = &to_render_state(ctx)->swtnl; nouveau_bo_ref(NULL, &swtnl->vbo); - swtnl->buf = get_scratch_vbo(ctx, RENDER_SCRATCH_SIZE, - &swtnl->vbo, NULL); + swtnl->buf = nouveau_get_scratch(ctx, SWTNL_VBO_SIZE, &swtnl->vbo, + &swtnl->offset); swtnl->vertex_count = 0; } @@ -168,14 +165,15 @@ swtnl_bind_vertices(struct gl_context *ctx) { struct nouveau_render_state *render = to_render_state(ctx); struct nouveau_swtnl_state *swtnl = &render->swtnl; + struct tnl_clipspace *vtx = &TNL_CONTEXT(ctx)->clipspace; int i; - for (i = 0; i < render->attr_count; i++) { - int attr = render->map[i]; + for (i = 0; i < vtx->attr_count; i++) { + struct tnl_clipspace_attr *ta = &vtx->attr[i]; + struct nouveau_array *a = &render->attrs[ta->attrib]; - if (attr >= 0) - nouveau_bo_ref(swtnl->vbo, - &render->attrs[attr].bo); + nouveau_bo_ref(swtnl->vbo, &a->bo); + a->offset = swtnl->offset + ta->vertoffset; } TAG(render_bind_vertices)(ctx); @@ -185,15 +183,11 @@ static void swtnl_unbind_vertices(struct gl_context *ctx) { struct nouveau_render_state *render = to_render_state(ctx); - int i; - - for (i = 0; i < render->attr_count; i++) { - int *attr = &render->map[i]; + int i, attr; - if (*attr >= 0) { - nouveau_bo_ref(NULL, &render->attrs[*attr].bo); - *attr = -1; - } + FOR_EACH_BOUND_ATTR(render, i, attr) { + nouveau_bo_ref(NULL, &render->attrs[attr].bo); + render->map[i] = -1; } render->attr_count = 0; @@ -260,7 +254,7 @@ swtnl_reset_stipple(struct gl_context *ctx) struct nouveau_swtnl_state *swtnl = &to_render_state(ctx)->swtnl; \ int vertex_len = TNL_CONTEXT(ctx)->clipspace.vertex_size; \ \ - if (swtnl->vertex_count + (n) > swtnl->vbo->size/vertex_len \ + if (swtnl->vertex_count + (n) > SWTNL_VBO_SIZE/vertex_len \ || (swtnl->vertex_count && swtnl->primitive != p)) \ swtnl_flush_vertices(ctx); \ \ @@ -280,7 +274,7 @@ swtnl_points(struct gl_context *ctx, GLuint first, GLuint last) while (first < last) { BEGIN_PRIMITIVE(GL_POINTS, last - first); - count = MIN2(swtnl->vbo->size / vertex_len, last - first); + count = MIN2(SWTNL_VBO_SIZE / vertex_len, last - first); for (i = 0; i < count; i++) OUT_VERTEX(first + i); @@ -316,7 +310,7 @@ swtnl_quad(struct gl_context *ctx, GLuint v1, GLuint v2, GLuint v3, GLuint v4) } /* TnL initialization. */ -static void +void TAG(swtnl_init)(struct gl_context *ctx) { TNLcontext *tnl = TNL_CONTEXT(ctx); @@ -347,7 +341,7 @@ TAG(swtnl_init)(struct gl_context *ctx) swtnl_alloc_vertices(ctx); } -static void +void TAG(swtnl_destroy)(struct gl_context *ctx) { nouveau_bo_ref(NULL, &to_render_state(ctx)->swtnl.vbo); diff --git a/src/mesa/drivers/dri/nouveau/nouveau_texture.c b/src/mesa/drivers/dri/nouveau/nouveau_texture.c index cd063702af..2480b1ea50 100644 --- a/src/mesa/drivers/dri/nouveau/nouveau_texture.c +++ b/src/mesa/drivers/dri/nouveau/nouveau_texture.c @@ -79,26 +79,65 @@ nouveau_teximage_free(struct gl_context *ctx, struct gl_texture_image *ti) } static void -nouveau_teximage_map(struct gl_context *ctx, struct gl_texture_image *ti) +nouveau_teximage_map(struct gl_context *ctx, struct gl_texture_image *ti, + int access, int x, int y, int w, int h) { - struct nouveau_surface *s = &to_nouveau_teximage(ti)->surface; - int ret; + struct nouveau_teximage *nti = to_nouveau_teximage(ti); + struct nouveau_surface *s = &nti->surface; + struct nouveau_surface *st = &nti->transfer.surface; if (s->bo) { - ret = nouveau_bo_map(s->bo, NOUVEAU_BO_RDWR); - assert(!ret); - - ti->Data = s->bo->map; + if (!(access & GL_MAP_READ_BIT) && + nouveau_bo_pending(s->bo)) { + /* + * Heuristic: use a bounce buffer to pipeline + * teximage transfers. + */ + st->layout = LINEAR; + st->format = s->format; + st->cpp = s->cpp; + st->width = w; + st->height = h; + st->pitch = s->pitch; + nti->transfer.x = x; + nti->transfer.y = y; + + ti->Data = nouveau_get_scratch(ctx, st->pitch * h, + &st->bo, &st->offset); + + } else { + int ret, flags = 0; + + if (access & GL_MAP_READ_BIT) + flags |= NOUVEAU_BO_RD; + if (access & GL_MAP_WRITE_BIT) + flags |= NOUVEAU_BO_WR; + + ret = nouveau_bo_map(s->bo, flags); + assert(!ret); + + ti->Data = s->bo->map + y * s->pitch + x * s->cpp; + } } } static void nouveau_teximage_unmap(struct gl_context *ctx, struct gl_texture_image *ti) { - struct nouveau_surface *s = &to_nouveau_teximage(ti)->surface; + struct nouveau_teximage *nti = to_nouveau_teximage(ti); + struct nouveau_surface *s = &nti->surface; + struct nouveau_surface *st = &nti->transfer.surface; - if (s->bo) + if (st->bo) { + context_drv(ctx)->surface_copy(ctx, s, st, nti->transfer.x, + nti->transfer.y, 0, 0, + st->width, st->height); + nouveau_surface_ref(NULL, st); + + } else if (s->bo) { nouveau_bo_unmap(s->bo); + } + ti->Data = NULL; } @@ -115,6 +154,7 @@ nouveau_choose_tex_format(struct gl_context *ctx, GLint internalFormat, case GL_RGBA12: case GL_RGBA16: case GL_RGB10_A2: + case GL_COMPRESSED_RGBA: return MESA_FORMAT_ARGB8888; case GL_RGB5_A1: return MESA_FORMAT_ARGB1555; @@ -124,6 +164,7 @@ nouveau_choose_tex_format(struct gl_context *ctx, GLint internalFormat, case GL_RGB10: case GL_RGB12: case GL_RGB16: + case GL_COMPRESSED_RGB: return MESA_FORMAT_XRGB8888; case 3: case GL_R3_G3_B2: @@ -139,6 +180,7 @@ nouveau_choose_tex_format(struct gl_context *ctx, GLint internalFormat, case GL_LUMINANCE12_ALPHA12: case GL_LUMINANCE16_ALPHA16: case GL_LUMINANCE8_ALPHA8: + case GL_COMPRESSED_LUMINANCE_ALPHA: return MESA_FORMAT_ARGB8888; case 1: @@ -147,6 +189,7 @@ nouveau_choose_tex_format(struct gl_context *ctx, GLint internalFormat, case GL_LUMINANCE12: case GL_LUMINANCE16: case GL_LUMINANCE8: + case GL_COMPRESSED_LUMINANCE: return MESA_FORMAT_L8; case GL_ALPHA: @@ -154,6 +197,7 @@ nouveau_choose_tex_format(struct gl_context *ctx, GLint internalFormat, case GL_ALPHA12: case GL_ALPHA16: case GL_ALPHA8: + case GL_COMPRESSED_ALPHA: return MESA_FORMAT_A8; case GL_INTENSITY: @@ -356,7 +400,8 @@ nouveau_teximage(struct gl_context *ctx, GLint dims, GLenum target, GLint level, "glTexImage"); if (pixels) { /* Store the pixel data. */ - nouveau_teximage_map(ctx, ti); + nouveau_teximage_map(ctx, ti, GL_MAP_WRITE_BIT, + 0, 0, width, height); ret = _mesa_texstore(ctx, dims, ti->_BaseFormat, ti->TexFormat, ti->Data, @@ -443,13 +488,13 @@ nouveau_texsubimage(struct gl_context *ctx, GLint dims, GLenum target, GLint lev format, type, pixels, packing, "glTexSubImage"); if (pixels) { - nouveau_teximage_map(ctx, ti); + nouveau_teximage_map(ctx, ti, GL_MAP_WRITE_BIT, + xoffset, yoffset, width, height); ret = _mesa_texstore(ctx, 3, ti->_BaseFormat, ti->TexFormat, - ti->Data, xoffset, yoffset, zoffset, - s->pitch, ti->ImageOffsets, - width, height, depth, format, type, - pixels, packing); + ti->Data, 0, 0, 0, s->pitch, + ti->ImageOffsets, width, height, depth, + format, type, pixels, packing); assert(ret); nouveau_teximage_unmap(ctx, ti); @@ -508,7 +553,8 @@ nouveau_get_teximage(struct gl_context *ctx, GLenum target, GLint level, struct gl_texture_object *t, struct gl_texture_image *ti) { - nouveau_teximage_map(ctx, ti); + nouveau_teximage_map(ctx, ti, GL_MAP_READ_BIT, + 0, 0, ti->Width, ti->Height); _mesa_get_teximage(ctx, target, level, format, type, pixels, t, ti); nouveau_teximage_unmap(ctx, ti); @@ -557,11 +603,12 @@ nouveau_set_texbuffer(__DRIcontext *dri_ctx, nouveau_update_renderbuffers(dri_ctx, draw); nouveau_surface_ref(&to_nouveau_renderbuffer(rb)->surface, s); + s->format = get_texbuffer_format(rb, format); + /* Update the image fields. */ _mesa_init_teximage_fields(ctx, target, ti, s->width, s->height, - 1, 0, s->cpp); + 1, 0, s->cpp, s->format); ti->RowStride = s->pitch / s->cpp; - ti->TexFormat = s->format = get_texbuffer_format(rb, format); /* Try to validate it. */ if (!validate_teximage(ctx, t, 0, 0, 0, 0, s->width, s->height, 1)) @@ -579,8 +626,11 @@ nouveau_texture_map(struct gl_context *ctx, struct gl_texture_object *t) int i; for (i = t->BaseLevel; i < t->_MaxLevel; i++) { - if (t->Image[0][i]) - nouveau_teximage_map(ctx, t->Image[0][i]); + struct gl_texture_image *ti = t->Image[0][i]; + + if (ti) + nouveau_teximage_map(ctx, ti, GL_MAP_READ_BIT, + 0, 0, ti->Width, ti->Height); } } @@ -630,7 +680,8 @@ nouveau_generate_mipmap(struct gl_context *ctx, GLenum target, if (_mesa_meta_check_generate_mipmap_fallback(ctx, target, t)) { struct gl_texture_image *base = t->Image[0][t->BaseLevel]; - nouveau_teximage_map(ctx, base); + nouveau_teximage_map(ctx, base, GL_MAP_READ_BIT, + 0, 0, base->Width, base->Height); _mesa_generate_mipmap(ctx, target, t); nouveau_teximage_unmap(ctx, base); diff --git a/src/mesa/drivers/dri/nouveau/nouveau_texture.h b/src/mesa/drivers/dri/nouveau/nouveau_texture.h index fc170215f3..56e61c7337 100644 --- a/src/mesa/drivers/dri/nouveau/nouveau_texture.h +++ b/src/mesa/drivers/dri/nouveau/nouveau_texture.h @@ -30,6 +30,10 @@ struct nouveau_teximage { struct gl_texture_image base; struct nouveau_surface surface; + struct { + struct nouveau_surface surface; + int x, y; + } transfer; }; #define to_nouveau_teximage(x) ((struct nouveau_teximage *)(x)) diff --git a/src/mesa/drivers/dri/nouveau/nouveau_util.h b/src/mesa/drivers/dri/nouveau/nouveau_util.h index 8df8867d14..6d01934dad 100644 --- a/src/mesa/drivers/dri/nouveau/nouveau_util.h +++ b/src/mesa/drivers/dri/nouveau/nouveau_util.h @@ -164,6 +164,12 @@ get_viewport_translate(struct gl_context *ctx, float a[4]) } static inline void +OUT_RINGb(struct nouveau_channel *chan, GLboolean x) +{ + OUT_RING(chan, x ? 1 : 0); +} + +static inline void OUT_RINGm(struct nouveau_channel *chan, float m[16]) { int i, j; diff --git a/src/mesa/drivers/dri/nouveau/nouveau_vbo_t.c b/src/mesa/drivers/dri/nouveau/nouveau_vbo_t.c index 394f3c9b50..d8b331cca7 100644 --- a/src/mesa/drivers/dri/nouveau/nouveau_vbo_t.c +++ b/src/mesa/drivers/dri/nouveau/nouveau_vbo_t.c @@ -31,59 +31,11 @@ #include "main/image.h" /* Arbitrary pushbuf length we can assume we can get with a single - * WAIT_RING. */ + * call to WAIT_RING. */ #define PUSHBUF_DWORDS 65536 -/* Functions to set up struct nouveau_array_state from something like - * a GL array or index buffer. */ - -static void -vbo_init_array(struct nouveau_array_state *a, int attr, int stride, - int fields, int type, struct gl_buffer_object *obj, - const void *ptr, GLboolean map) -{ - a->attr = attr; - a->stride = stride; - a->fields = fields; - a->type = type; - - if (_mesa_is_bufferobj(obj)) { - nouveau_bo_ref(to_nouveau_bufferobj(obj)->bo, &a->bo); - a->offset = (intptr_t)ptr; - - if (map) { - nouveau_bo_map(a->bo, NOUVEAU_BO_RD); - a->buf = a->bo->map + a->offset; - } else { - a->buf = NULL; - } - - } else { - nouveau_bo_ref(NULL, &a->bo); - a->offset = 0; - - if (map) - a->buf = ptr; - else - a->buf = NULL; - } - - if (a->buf) - get_array_extract(a, &a->extract_u, &a->extract_f); -} - -static void -vbo_deinit_array(struct nouveau_array_state *a) -{ - if (a->bo) { - if (a->bo->map) - nouveau_bo_unmap(a->bo); - nouveau_bo_ref(NULL, &a->bo); - } - - a->buf = NULL; - a->fields = 0; -} +/* Functions to turn GL arrays or index buffers into nouveau_array + * structures. */ static int get_array_stride(struct gl_context *ctx, const struct gl_client_array *a) @@ -102,48 +54,45 @@ vbo_init_arrays(struct gl_context *ctx, const struct _mesa_index_buffer *ib, const struct gl_client_array **arrays) { struct nouveau_render_state *render = to_render_state(ctx); - int i; + GLboolean imm = (render->mode == IMM); + int i, attr; if (ib) - vbo_init_array(&render->ib, 0, 0, ib->count, ib->type, - ib->obj, ib->ptr, GL_TRUE); + nouveau_init_array(&render->ib, 0, 0, ib->count, ib->type, + ib->obj, ib->ptr, GL_TRUE); - for (i = 0; i < render->attr_count; i++) { - int attr = render->map[i]; + FOR_EACH_BOUND_ATTR(render, i, attr) { + const struct gl_client_array *array = arrays[attr]; - if (attr >= 0) { - const struct gl_client_array *array = arrays[attr]; - - vbo_init_array(&render->attrs[attr], attr, - get_array_stride(ctx, array), - array->Size, array->Type, - array->BufferObj, array->Ptr, - render->mode == IMM); - } + nouveau_init_array(&render->attrs[attr], attr, + get_array_stride(ctx, array), + array->Size, array->Type, + imm ? array->BufferObj : NULL, + array->Ptr, imm); } } static void vbo_deinit_arrays(struct gl_context *ctx, const struct _mesa_index_buffer *ib, - const struct gl_client_array **arrays) + const struct gl_client_array **arrays) { struct nouveau_render_state *render = to_render_state(ctx); - int i; + int i, attr; if (ib) - vbo_deinit_array(&render->ib); + nouveau_cleanup_array(&render->ib); - for (i = 0; i < render->attr_count; i++) { - int *attr = &render->map[i]; + FOR_EACH_BOUND_ATTR(render, i, attr) { + struct nouveau_array *a = &render->attrs[attr]; - if (*attr >= 0) { - vbo_deinit_array(&render->attrs[*attr]); - *attr = -1; - } + if (render->mode == IMM) + nouveau_bo_ref(NULL, &a->bo); + + nouveau_deinit_array(a); + render->map[i] = -1; } render->attr_count = 0; - context_bctx(ctx, VERTEX); } /* Make some rendering decisions from the GL context. */ @@ -164,20 +113,16 @@ vbo_choose_render_mode(struct gl_context *ctx, const struct gl_client_array **ar } } } - - if (render->mode == VBO) - render->attr_count = NUM_VERTEX_ATTRS; - else - render->attr_count = 0; } static void -vbo_emit_attr(struct gl_context *ctx, const struct gl_client_array **arrays, int attr) +vbo_emit_attr(struct gl_context *ctx, const struct gl_client_array **arrays, + int attr) { struct nouveau_channel *chan = context_chan(ctx); struct nouveau_render_state *render = to_render_state(ctx); const struct gl_client_array *array = arrays[attr]; - struct nouveau_array_state *a = &render->attrs[attr]; + struct nouveau_array *a = &render->attrs[attr]; RENDER_LOCALS(ctx); if (!array->StrideB) { @@ -186,11 +131,11 @@ vbo_emit_attr(struct gl_context *ctx, const struct gl_client_array **arrays, int return; /* Constant attribute. */ - vbo_init_array(a, attr, array->StrideB, array->Size, - array->Type, array->BufferObj, array->Ptr, - GL_TRUE); + nouveau_init_array(a, attr, array->StrideB, array->Size, + array->Type, array->BufferObj, array->Ptr, + GL_TRUE); EMIT_IMM(ctx, a, 0); - vbo_deinit_array(a); + nouveau_deinit_array(a); } else { /* Varying attribute. */ @@ -199,6 +144,8 @@ vbo_emit_attr(struct gl_context *ctx, const struct gl_client_array **arrays, int if (render->mode == VBO) { render->map[info->vbo_index] = attr; render->vertex_size += array->_ElementSize; + render->attr_count = MAX2(render->attr_count, + info->vbo_index + 1); } else { render->map[render->attr_count++] = attr; render->vertex_size += 4 * info->imm_fields; @@ -216,6 +163,7 @@ vbo_choose_attrs(struct gl_context *ctx, const struct gl_client_array **arrays) /* Reset the vertex size. */ render->vertex_size = 0; + render->attr_count = 0; vbo_emit_attr(ctx, arrays, VERT_ATTRIB_COLOR0); if (ctx->Fog.ColorSumEnabled && !ctx->Light.Enabled) @@ -233,7 +181,7 @@ vbo_choose_attrs(struct gl_context *ctx, const struct gl_client_array **arrays) (ctx->Texture._GenFlags & TEXGEN_NEED_NORMALS)) vbo_emit_attr(ctx, arrays, VERT_ATTRIB_NORMAL); - if (ctx->Light.Enabled) { + if (ctx->Light.Enabled && render->mode == IMM) { vbo_emit_attr(ctx, arrays, MAT(FRONT_AMBIENT)); vbo_emit_attr(ctx, arrays, MAT(FRONT_DIFFUSE)); vbo_emit_attr(ctx, arrays, MAT(FRONT_SPECULAR)); @@ -254,17 +202,13 @@ static int get_max_client_stride(struct gl_context *ctx, const struct gl_client_array **arrays) { struct nouveau_render_state *render = to_render_state(ctx); - int i, s = 0; - - for (i = 0; i < render->attr_count; i++) { - int attr = render->map[i]; + int i, attr, s = 0; - if (attr >= 0) { - const struct gl_client_array *a = arrays[attr]; + FOR_EACH_BOUND_ATTR(render, i, attr) { + const struct gl_client_array *a = arrays[attr]; - if (!_mesa_is_bufferobj(a->BufferObj)) - s = MAX2(s, get_array_stride(ctx, a)); - } + if (!_mesa_is_bufferobj(a->BufferObj)) + s = MAX2(s, get_array_stride(ctx, a)); } return s; @@ -295,7 +239,7 @@ vbo_maybe_split(struct gl_context *ctx, const struct gl_client_array **arrays, if (render->mode == VBO && (stride = get_max_client_stride(ctx, arrays))) vert_avail = MIN2(vert_avail, - RENDER_SCRATCH_SIZE / stride); + NOUVEAU_SCRATCH_SIZE / stride); if (max_index - min_index > vert_avail || (ib && ib->count > idx_avail)) { @@ -315,42 +259,93 @@ vbo_maybe_split(struct gl_context *ctx, const struct gl_client_array **arrays, /* VBO rendering path. */ +static GLboolean +check_update_array(struct nouveau_array *a, unsigned offset, + struct nouveau_bo *bo, int *pdelta) +{ + int delta = *pdelta; + GLboolean dirty; + + if (a->bo == bo) { + if (delta < 0) + delta = ((int)offset - (int)a->offset) / a->stride; + + dirty = (delta < 0 || + offset != (a->offset + delta * a->stride)); + } else { + dirty = GL_TRUE; + } + + *pdelta = (dirty ? 0 : delta); + return dirty; +} + static void vbo_bind_vertices(struct gl_context *ctx, const struct gl_client_array **arrays, - GLint basevertex, GLuint min_index, GLuint max_index) + int base, unsigned min_index, unsigned max_index, int *pdelta) { struct nouveau_render_state *render = to_render_state(ctx); - int i; + struct nouveau_channel *chan = context_chan(ctx); + struct nouveau_bo *bo[NUM_VERTEX_ATTRS]; + unsigned offset[NUM_VERTEX_ATTRS]; + GLboolean dirty = GL_FALSE; + int i, j, attr; + RENDER_LOCALS(ctx); - for (i = 0; i < NUM_VERTEX_ATTRS; i++) { - int attr = render->map[i]; - - if (attr >= 0) { - const struct gl_client_array *array = arrays[attr]; - struct nouveau_array_state *a = &render->attrs[attr]; - unsigned delta = (basevertex + min_index) - * array->StrideB; - - if (a->bo) { - /* Array in a buffer obj. */ - a->offset = (intptr_t)array->Ptr + delta; - } else { - int j, n = max_index - min_index + 1; - char *sp = (char *)array->Ptr + delta; - char *dp = get_scratch_vbo(ctx, n * a->stride, - &a->bo, &a->offset); - - /* Array in client memory, move it to - * a scratch buffer obj. */ - for (j = 0; j < n; j++) - memcpy(dp + j * a->stride, - sp + j * array->StrideB, - a->stride); - } + *pdelta = -1; + + FOR_EACH_BOUND_ATTR(render, i, attr) { + const struct gl_client_array *array = arrays[attr]; + struct gl_buffer_object *obj = array->BufferObj; + struct nouveau_array *a = &render->attrs[attr]; + unsigned delta = (base + min_index) * array->StrideB; + + bo[i] = NULL; + + if (nouveau_bufferobj_hw(obj)) { + /* Array in a buffer obj. */ + nouveau_bo_ref(to_nouveau_bufferobj(obj)->bo, &bo[i]); + offset[i] = delta + (intptr_t)array->Ptr; + + } else { + int n = max_index - min_index + 1; + char *sp = (char *)ADD_POINTERS( + nouveau_bufferobj_sys(obj), array->Ptr) + delta; + char *dp = nouveau_get_scratch(ctx, n * a->stride, + &bo[i], &offset[i]); + + /* Array in client memory, move it to a + * scratch buffer obj. */ + for (j = 0; j < n; j++) + memcpy(dp + j * a->stride, + sp + j * array->StrideB, + a->stride); + } + + dirty |= check_update_array(a, offset[i], bo[i], pdelta); + } + + *pdelta -= min_index; + + if (dirty) { + /* Buffers changed, update the attribute binding. */ + FOR_EACH_BOUND_ATTR(render, i, attr) { + struct nouveau_array *a = &render->attrs[attr]; + + nouveau_bo_ref(NULL, &a->bo); + a->offset = offset[i]; + a->bo = bo[i]; } + + TAG(render_bind_vertices)(ctx); + + } else { + /* Just cleanup. */ + FOR_EACH_BOUND_ATTR(render, i, attr) + nouveau_bo_ref(NULL, &bo[i]); } - TAG(render_bind_vertices)(ctx); + BATCH_VALIDATE(); } static void @@ -360,12 +355,10 @@ vbo_draw_vbo(struct gl_context *ctx, const struct gl_client_array **arrays, GLuint max_index) { struct nouveau_channel *chan = context_chan(ctx); - dispatch_t dispatch; - int delta = -min_index, basevertex = 0, i; + dispatch_t dispatch = get_array_dispatch(&to_render_state(ctx)->ib); + int i, delta = 0, basevertex = 0; RENDER_LOCALS(ctx); - get_array_dispatch(&to_render_state(ctx)->ib, &dispatch); - TAG(render_set_format)(ctx); for (i = 0; i < nr_prims; i++) { @@ -374,8 +367,8 @@ vbo_draw_vbo(struct gl_context *ctx, const struct gl_client_array **arrays, if (i == 0 || basevertex != prims[i].basevertex) { basevertex = prims[i].basevertex; - vbo_bind_vertices(ctx, arrays, basevertex, - min_index, max_index); + vbo_bind_vertices(ctx, arrays, basevertex, min_index, + max_index, &delta); } if (count > get_max_vertices(ctx, ib, AVAIL_RING(chan))) @@ -390,7 +383,7 @@ vbo_draw_vbo(struct gl_context *ctx, const struct gl_client_array **arrays, /* Immediate rendering path. */ static unsigned -extract_id(struct nouveau_array_state *a, int i, int j) +extract_id(struct nouveau_array *a, int i, int j) { return j; } @@ -404,7 +397,7 @@ vbo_draw_imm(struct gl_context *ctx, const struct gl_client_array **arrays, struct nouveau_render_state *render = to_render_state(ctx); struct nouveau_channel *chan = context_chan(ctx); extract_u_t extract = ib ? render->ib.extract_u : extract_id; - int i, j, k; + int i, j, k, attr; RENDER_LOCALS(ctx); for (i = 0; i < nr_prims; i++) { @@ -421,9 +414,8 @@ vbo_draw_imm(struct gl_context *ctx, const struct gl_client_array **arrays, j = prims[i].basevertex + extract(&render->ib, 0, start); - for (k = 0; k < render->attr_count; k++) - EMIT_IMM(ctx, &render->attrs[render->map[k]], - j); + FOR_EACH_BOUND_ATTR(render, k, attr) + EMIT_IMM(ctx, &render->attrs[attr], j); } BATCH_END(); @@ -433,7 +425,8 @@ vbo_draw_imm(struct gl_context *ctx, const struct gl_client_array **arrays, /* draw_prims entry point when we're doing hw-tnl. */ static void -TAG(vbo_render_prims)(struct gl_context *ctx, const struct gl_client_array **arrays, +TAG(vbo_render_prims)(struct gl_context *ctx, + const struct gl_client_array **arrays, const struct _mesa_prim *prims, GLuint nr_prims, const struct _mesa_index_buffer *ib, GLboolean index_bounds_valid, @@ -462,3 +455,44 @@ TAG(vbo_render_prims)(struct gl_context *ctx, const struct gl_client_array **arr vbo_deinit_arrays(ctx, ib, arrays); } + +/* VBO rendering entry points. */ + +static void +TAG(vbo_check_render_prims)(struct gl_context *ctx, + const struct gl_client_array **arrays, + const struct _mesa_prim *prims, GLuint nr_prims, + const struct _mesa_index_buffer *ib, + GLboolean index_bounds_valid, + GLuint min_index, GLuint max_index) +{ + struct nouveau_context *nctx = to_nouveau_context(ctx); + + nouveau_validate_framebuffer(ctx); + + if (nctx->fallback == HWTNL) + TAG(vbo_render_prims)(ctx, arrays, prims, nr_prims, ib, + index_bounds_valid, min_index, max_index); + + if (nctx->fallback == SWTNL) + _tnl_vbo_draw_prims(ctx, arrays, prims, nr_prims, ib, + index_bounds_valid, min_index, max_index); +} + +void +TAG(vbo_init)(struct gl_context *ctx) +{ + struct nouveau_render_state *render = to_render_state(ctx); + int i; + + for (i = 0; i < VERT_ATTRIB_MAX; i++) + render->map[i] = -1; + + vbo_set_draw_func(ctx, TAG(vbo_check_render_prims)); + vbo_use_buffer_objects(ctx); +} + +void +TAG(vbo_destroy)(struct gl_context *ctx) +{ +} diff --git a/src/mesa/drivers/dri/nouveau/nv01_2d.xml.h b/src/mesa/drivers/dri/nouveau/nv01_2d.xml.h new file mode 100644 index 0000000000..3390da089b --- /dev/null +++ b/src/mesa/drivers/dri/nouveau/nv01_2d.xml.h @@ -0,0 +1,1343 @@ +#ifndef NV01_2D_XML +#define NV01_2D_XML + +/* Autogenerated file, DO NOT EDIT manually! + +This file was generated by the rules-ng-ng headergen tool in this git repository: +http://0x04.net/cgit/index.cgi/rules-ng-ng +git clone git://0x04.net/rules-ng-ng + +The rules-ng-ng source files this header was generated from are: +- nv01_2d.xml ( 33509 bytes, from 2010-11-13 23:32:57) +- copyright.xml ( 6452 bytes, from 2010-11-15 15:10:58) +- nv_defs.xml ( 4437 bytes, from 2010-11-01 00:28:46) +- nv_object.xml ( 11547 bytes, from 2010-11-13 23:32:57) +- nvchipsets.xml ( 3074 bytes, from 2010-11-13 23:32:57) + +Copyright (C) 2006-2010 by the following authors: +- Artur Huillet <arthur.huillet@free.fr> (ahuillet) +- Ben Skeggs (darktama, darktama_) +- B. R. <koala_br@users.sourceforge.net> (koala_br) +- Carlos Martin <carlosmn@users.sf.net> (carlosmn) +- Christoph Bumiller <e0425955@student.tuwien.ac.at> (calim, chrisbmr) +- Dawid Gajownik <gajownik@users.sf.net> (gajownik) +- Dmitry Baryshkov +- Dmitry Eremin-Solenikov <lumag@users.sf.net> (lumag) +- EdB <edb_@users.sf.net> (edb_) +- Erik Waling <erikwailing@users.sf.net> (erikwaling) +- Francisco Jerez <currojerez@riseup.net> (curro) +- imirkin <imirkin@users.sf.net> (imirkin) +- jb17bsome <jb17bsome@bellsouth.net> (jb17bsome) +- Jeremy Kolb <kjeremy@users.sf.net> (kjeremy) +- Laurent Carlier <lordheavym@gmail.com> (lordheavy) +- Luca Barbieri <luca@luca-barbieri.com> (lb, lb1) +- Maarten Maathuis <madman2003@gmail.com> (stillunknown) +- Marcin Kościelnicki <koriakin@0x04.net> (mwk, koriakin) +- Mark Carey <mark.carey@gmail.com> (careym) +- Matthieu Castet <matthieu.castet@parrot.com> (mat-c) +- nvidiaman <nvidiaman@users.sf.net> (nvidiaman) +- Patrice Mandin <patmandin@gmail.com> (pmandin, pmdata) +- Pekka Paalanen <pq@iki.fi> (pq, ppaalanen) +- Peter Popov <ironpeter@users.sf.net> (ironpeter) +- Richard Hughes <hughsient@users.sf.net> (hughsient) +- Rudi Cilibrasi <cilibrar@users.sf.net> (cilibrar) +- Serge Martin +- Simon Raffeiner +- Stephane Loeuillet <leroutier@users.sf.net> (leroutier) +- Stephane Marchesin <stephane.marchesin@gmail.com> (marcheu) +- sturmflut <sturmflut@users.sf.net> (sturmflut) +- Sylvain Munaut <tnt@246tNt.com> +- Victor Stinner <victor.stinner@haypocalc.com> (haypo) +- Wladmir van der Laan <laanwj@gmail.com> (miathan6) +- Younes Manton <younes.m@gmail.com> (ymanton) + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial +portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + + + +#define NV01_CONTEXT_BETA1_DMA_NOTIFY 0x00000180 + +#define NV01_CONTEXT_BETA1_BETA_1D31 0x00000300 + + +#define NV04_BETA_SOLID_DMA_NOTIFY 0x00000180 + +#define NV04_BETA_SOLID_BETA_FACTOR 0x00000300 + + +#define NV01_CONTEXT_COLOR_KEY_DMA_NOTIFY 0x00000180 + +#define NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT 0x00000300 +#define NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_A16R5G6B5 0x00000001 +#define NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_X16A1R5G5B5 0x00000002 +#define NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_A8R8G8B8 0x00000003 + +#define NV01_CONTEXT_COLOR_KEY_COLOR 0x00000304 + + +#define NV01_CONTEXT_PATTERN_DMA_NOTIFY 0x00000180 + +#define NV01_CONTEXT_PATTERN_COLOR_FORMAT 0x00000300 + +#define NV01_CONTEXT_PATTERN_MONOCHROME_FORMAT 0x00000304 + +#define NV01_CONTEXT_PATTERN_SHAPE 0x00000308 + +#define NV01_CONTEXT_PATTERN_COLOR(i0) (0x00000310 + 0x4*(i0)) +#define NV01_CONTEXT_PATTERN_COLOR__ESIZE 0x00000004 +#define NV01_CONTEXT_PATTERN_COLOR__LEN 0x00000002 + +#define NV01_CONTEXT_PATTERN_PATTERN(i0) (0x00000318 + 0x4*(i0)) +#define NV01_CONTEXT_PATTERN_PATTERN__ESIZE 0x00000004 +#define NV01_CONTEXT_PATTERN_PATTERN__LEN 0x00000002 + + +#define NV01_CONTEXT_CLIP_RECTANGLE_DMA_NOTIFY 0x00000180 + +#define NV01_CONTEXT_CLIP_RECTANGLE_POINT 0x00000300 +#define NV01_CONTEXT_CLIP_RECTANGLE_POINT_X__MASK 0x0000ffff +#define NV01_CONTEXT_CLIP_RECTANGLE_POINT_X__SHIFT 0 +#define NV01_CONTEXT_CLIP_RECTANGLE_POINT_Y__MASK 0xffff0000 +#define NV01_CONTEXT_CLIP_RECTANGLE_POINT_Y__SHIFT 16 + +#define NV01_CONTEXT_CLIP_RECTANGLE_SIZE 0x00000304 +#define NV01_CONTEXT_CLIP_RECTANGLE_SIZE_W__MASK 0x0000ffff +#define NV01_CONTEXT_CLIP_RECTANGLE_SIZE_W__SHIFT 0 +#define NV01_CONTEXT_CLIP_RECTANGLE_SIZE_H__MASK 0xffff0000 +#define NV01_CONTEXT_CLIP_RECTANGLE_SIZE_H__SHIFT 16 + + +#define NV04_CONTEXT_SURFACES_2D_DMA_NOTIFY 0x00000180 + +#define NV04_CONTEXT_SURFACES_2D_DMA_IMAGE_SOURCE 0x00000184 + +#define NV04_CONTEXT_SURFACES_2D_DMA_IMAGE_DESTIN 0x00000188 + + +#define NV50_CONTEXT_SURFACES_2D_SRC_LINEAR 0x00000200 + +#define NV50_CONTEXT_SURFACES_2D_SRC_TILE_MODE 0x00000204 + +#define NV50_CONTEXT_SURFACES_2D_SRC_WIDTH 0x00000208 + +#define NV50_CONTEXT_SURFACES_2D_SRC_HEIGHT 0x0000020c + +#define NV50_CONTEXT_SURFACES_2D_UNK0210 0x00000210 + +#define NV50_CONTEXT_SURFACES_2D_UNK0214 0x00000214 + +#define NV50_CONTEXT_SURFACES_2D_DST_LINEAR 0x00000218 + +#define NV50_CONTEXT_SURFACES_2D_DST_TILE_MODE 0x0000021c + +#define NV50_CONTEXT_SURFACES_2D_DST_WIDTH 0x00000220 + +#define NV50_CONTEXT_SURFACES_2D_DST_HEIGHT 0x00000224 + +#define NV50_CONTEXT_SURFACES_2D_UNK0228 0x00000228 + +#define NV50_CONTEXT_SURFACES_2D_UNK022C 0x0000022c + +#define NV50_CONTEXT_SURFACES_2D_OFFSET_SOURCE_HIGH 0x00000230 + +#define NV50_CONTEXT_SURFACES_2D_OFFSET_DESTIN_HIGH 0x00000234 + +#define NV04_CONTEXT_SURFACES_2D_FORMAT 0x00000300 +#define NV04_CONTEXT_SURFACES_2D_FORMAT_Y8 0x00000001 +#define NV04_CONTEXT_SURFACES_2D_FORMAT_X1R5G5B5_Z1R5G5B5 0x00000002 +#define NV04_CONTEXT_SURFACES_2D_FORMAT_X1R5G5B5_X1R5G5B5 0x00000003 +#define NV04_CONTEXT_SURFACES_2D_FORMAT_R5G6B5 0x00000004 +#define NV04_CONTEXT_SURFACES_2D_FORMAT_Y16 0x00000005 +#define NV04_CONTEXT_SURFACES_2D_FORMAT_X8R8G8B8_Z8R8G8B8 0x00000006 +#define NV04_CONTEXT_SURFACES_2D_FORMAT_X8R8G8B8_X8R8G8B8 0x00000007 +#define NV04_CONTEXT_SURFACES_2D_FORMAT_X1A7R8G8B8_Z1A7R8G8B8 0x00000008 +#define NV04_CONTEXT_SURFACES_2D_FORMAT_X1A7R8G8B8_X1A7R8G8B8 0x00000009 +#define NV04_CONTEXT_SURFACES_2D_FORMAT_A8R8G8B8 0x0000000a +#define NV04_CONTEXT_SURFACES_2D_FORMAT_Y32 0x0000000b + +#define NV04_CONTEXT_SURFACES_2D_PITCH 0x00000304 +#define NV04_CONTEXT_SURFACES_2D_PITCH_SOURCE__MASK 0x0000ffff +#define NV04_CONTEXT_SURFACES_2D_PITCH_SOURCE__SHIFT 0 +#define NV04_CONTEXT_SURFACES_2D_PITCH_DESTIN__MASK 0xffff0000 +#define NV04_CONTEXT_SURFACES_2D_PITCH_DESTIN__SHIFT 16 + +#define NV04_CONTEXT_SURFACES_2D_OFFSET_SOURCE 0x00000308 + +#define NV04_CONTEXT_SURFACES_2D_OFFSET_DESTIN 0x0000030c + + +#define NV04_SWIZZLED_SURFACE_DMA_NOTIFY 0x00000180 + +#define NV04_SWIZZLED_SURFACE_DMA_IMAGE 0x00000184 + +#define NV04_SWIZZLED_SURFACE_FORMAT 0x00000300 +#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR__MASK 0x000000ff +#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR__SHIFT 0 +#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_Y8 0x00000001 +#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X1R5G5B5_Z1R5G5B5 0x00000002 +#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X1R5G5B5_X1R5G5B5 0x00000003 +#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_R5G6B5 0x00000004 +#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_Y16 0x00000005 +#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X8R8G8B8_Z8R8G8B8 0x00000006 +#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X8R8G8B8_X8R8G8B8 0x00000007 +#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X1A7R8G8B8_Z1A7R8G8B8 0x00000008 +#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X1A7R8G8B8_X1A7R8G8B8 0x00000009 +#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_A8R8G8B8 0x0000000a +#define NV04_SWIZZLED_SURFACE_FORMAT_COLOR_Y32 0x0000000b +#define NV04_SWIZZLED_SURFACE_FORMAT_BASE_SIZE_U__MASK 0x00ff0000 +#define NV04_SWIZZLED_SURFACE_FORMAT_BASE_SIZE_U__SHIFT 16 +#define NV04_SWIZZLED_SURFACE_FORMAT_BASE_SIZE_V__MASK 0xff000000 +#define NV04_SWIZZLED_SURFACE_FORMAT_BASE_SIZE_V__SHIFT 24 + +#define NV04_SWIZZLED_SURFACE_OFFSET 0x00000304 + + +#define NV03_CONTEXT_ROP_DMA_NOTIFY 0x00000180 + +#define NV03_CONTEXT_ROP_ROP 0x00000300 + + +#define NV04_IMAGE_PATTERN_DMA_NOTIFY 0x00000180 + +#define NV04_IMAGE_PATTERN_COLOR_FORMAT 0x00000300 +#define NV04_IMAGE_PATTERN_COLOR_FORMAT_A16R5G6B5 0x00000001 +#define NV04_IMAGE_PATTERN_COLOR_FORMAT_X16A1R5G5B5 0x00000002 +#define NV04_IMAGE_PATTERN_COLOR_FORMAT_A8R8G8B8 0x00000003 + +#define NV04_IMAGE_PATTERN_MONOCHROME_FORMAT 0x00000304 +#define NV04_IMAGE_PATTERN_MONOCHROME_FORMAT_CGA6 0x00000001 +#define NV04_IMAGE_PATTERN_MONOCHROME_FORMAT_LE 0x00000002 + +#define NV04_IMAGE_PATTERN_MONOCHROME_SHAPE 0x00000308 +#define NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_8X8 0x00000000 +#define NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_64X1 0x00000001 +#define NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_1X64 0x00000002 + +#define NV04_IMAGE_PATTERN_PATTERN_SELECT 0x0000030c +#define NV04_IMAGE_PATTERN_PATTERN_SELECT_MONO 0x00000001 +#define NV04_IMAGE_PATTERN_PATTERN_SELECT_COLOR 0x00000002 + +#define NV04_IMAGE_PATTERN_MONOCHROME_COLOR0 0x00000310 + +#define NV04_IMAGE_PATTERN_MONOCHROME_COLOR1 0x00000314 + +#define NV04_IMAGE_PATTERN_MONOCHROME_PATTERN0 0x00000318 + +#define NV04_IMAGE_PATTERN_MONOCHROME_PATTERN1 0x0000031c + +#define NV04_IMAGE_PATTERN_PATTERN_Y8(i0) (0x00000400 + 0x4*(i0)) +#define NV04_IMAGE_PATTERN_PATTERN_Y8__ESIZE 0x00000004 +#define NV04_IMAGE_PATTERN_PATTERN_Y8__LEN 0x00000010 +#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y0__MASK 0x000000ff +#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y0__SHIFT 0 +#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y1__MASK 0x0000ff00 +#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y1__SHIFT 8 +#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y2__MASK 0x00ff0000 +#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y2__SHIFT 16 +#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y3__MASK 0xff000000 +#define NV04_IMAGE_PATTERN_PATTERN_Y8_Y3__SHIFT 24 + +#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5(i0) (0x00000500 + 0x4*(i0)) +#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5__ESIZE 0x00000004 +#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5__LEN 0x00000020 +#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_B0__MASK 0x0000001f +#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_B0__SHIFT 0 +#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_G0__MASK 0x000007e0 +#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_G0__SHIFT 5 +#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_R0__MASK 0x0000f800 +#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_R0__SHIFT 11 +#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_B1__MASK 0x001f0000 +#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_B1__SHIFT 16 +#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_G1__MASK 0x07e00000 +#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_G1__SHIFT 21 +#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_R1__MASK 0xf8000000 +#define NV04_IMAGE_PATTERN_PATTERN_R5G6B5_R1__SHIFT 27 + +#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5(i0) (0x00000600 + 0x4*(i0)) +#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5__ESIZE 0x00000004 +#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5__LEN 0x00000020 +#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_B0__MASK 0x0000001f +#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_B0__SHIFT 0 +#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_G0__MASK 0x000003e0 +#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_G0__SHIFT 5 +#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_R0__MASK 0x00007c00 +#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_R0__SHIFT 10 +#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_B1__MASK 0x001f0000 +#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_B1__SHIFT 16 +#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_G1__MASK 0x03e00000 +#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_G1__SHIFT 21 +#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_R1__MASK 0x7c000000 +#define NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_R1__SHIFT 26 + +#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8(i0) (0x00000700 + 0x4*(i0)) +#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8__ESIZE 0x00000004 +#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8__LEN 0x00000040 +#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_B__MASK 0x000000ff +#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_B__SHIFT 0 +#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_G__MASK 0x0000ff00 +#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_G__SHIFT 8 +#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_R__MASK 0x00ff0000 +#define NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_R__SHIFT 16 + + +#define NV01_RENDER_SOLID_LINE_PATCH 0x0000010c + +#define NV01_RENDER_SOLID_LINE_DMA_NOTIFY 0x00000180 + +#define NV01_RENDER_SOLID_LINE_CLIP_RECTANGLE 0x00000184 + +#define NV01_RENDER_SOLID_LINE_PATTERN 0x00000188 + +#define NV04_RENDER_SOLID_LINE_PATTERN 0x00000188 + +#define NV01_RENDER_SOLID_LINE_ROP 0x0000018c + +#define NV01_RENDER_SOLID_LINE_BETA1 0x00000190 + +#define NV01_RENDER_SOLID_LINE_SURFACE_DST 0x00000194 + + +#define NV04_RENDER_SOLID_LINE_BETA4 0x00000194 + +#define NV04_RENDER_SOLID_LINE_SURFACE 0x00000198 + +#define NV01_RENDER_SOLID_LINE_OPERATION 0x000002fc +#define NV01_RENDER_SOLID_LINE_OPERATION_SRCCOPY_AND 0x00000000 +#define NV01_RENDER_SOLID_LINE_OPERATION_ROP_AND 0x00000001 +#define NV01_RENDER_SOLID_LINE_OPERATION_BLEND_AND 0x00000002 +#define NV01_RENDER_SOLID_LINE_OPERATION_SRCCOPY 0x00000003 +#define NV01_RENDER_SOLID_LINE_OPERATION_SRCCOPY_PREMULT 0x00000004 +#define NV01_RENDER_SOLID_LINE_OPERATION_BLEND_PREMULT 0x00000005 + +#define NV01_RENDER_SOLID_LINE_COLOR_FORMAT 0x00000300 +#define NV01_RENDER_SOLID_LINE_COLOR_FORMAT_A16R5G6B5 0x00000001 +#define NV01_RENDER_SOLID_LINE_COLOR_FORMAT_X16A1R5G5B5 0x00000002 +#define NV01_RENDER_SOLID_LINE_COLOR_FORMAT_A8R8G8B8 0x00000003 + +#define NV01_RENDER_SOLID_LINE_COLOR 0x00000304 + +#define NV01_RENDER_SOLID_LINE_LINE_POINT0(i0) (0x00000400 + 0x8*(i0)) +#define NV01_RENDER_SOLID_LINE_LINE_POINT0__ESIZE 0x00000008 +#define NV01_RENDER_SOLID_LINE_LINE_POINT0__LEN 0x00000010 +#define NV01_RENDER_SOLID_LINE_LINE_POINT0_X__MASK 0x0000ffff +#define NV01_RENDER_SOLID_LINE_LINE_POINT0_X__SHIFT 0 +#define NV01_RENDER_SOLID_LINE_LINE_POINT0_Y__MASK 0xffff0000 +#define NV01_RENDER_SOLID_LINE_LINE_POINT0_Y__SHIFT 16 + +#define NV01_RENDER_SOLID_LINE_LINE_POINT1(i0) (0x00000404 + 0x8*(i0)) +#define NV01_RENDER_SOLID_LINE_LINE_POINT1__ESIZE 0x00000008 +#define NV01_RENDER_SOLID_LINE_LINE_POINT1__LEN 0x00000010 +#define NV01_RENDER_SOLID_LINE_LINE_POINT1_X__MASK 0x0000ffff +#define NV01_RENDER_SOLID_LINE_LINE_POINT1_X__SHIFT 0 +#define NV01_RENDER_SOLID_LINE_LINE_POINT1_Y__MASK 0xffff0000 +#define NV01_RENDER_SOLID_LINE_LINE_POINT1_Y__SHIFT 16 + +#define NV01_RENDER_SOLID_LINE_LINE32_POINT0_X(i0) (0x00000480 + 0x10*(i0)) +#define NV01_RENDER_SOLID_LINE_LINE32_POINT0_X__ESIZE 0x00000010 +#define NV01_RENDER_SOLID_LINE_LINE32_POINT0_X__LEN 0x00000010 + +#define NV01_RENDER_SOLID_LINE_LINE32_POINT0_Y(i0) (0x00000484 + 0x10*(i0)) +#define NV01_RENDER_SOLID_LINE_LINE32_POINT0_Y__ESIZE 0x00000010 +#define NV01_RENDER_SOLID_LINE_LINE32_POINT0_Y__LEN 0x00000010 + +#define NV01_RENDER_SOLID_LINE_LINE32_POINT1_X(i0) (0x00000488 + 0x10*(i0)) +#define NV01_RENDER_SOLID_LINE_LINE32_POINT1_X__ESIZE 0x00000010 +#define NV01_RENDER_SOLID_LINE_LINE32_POINT1_X__LEN 0x00000010 + +#define NV01_RENDER_SOLID_LINE_LINE32_POINT1_Y(i0) (0x0000048c + 0x10*(i0)) +#define NV01_RENDER_SOLID_LINE_LINE32_POINT1_Y__ESIZE 0x00000010 +#define NV01_RENDER_SOLID_LINE_LINE32_POINT1_Y__LEN 0x00000010 + +#define NV01_RENDER_SOLID_LINE_POLYLINE(i0) (0x00000500 + 0x4*(i0)) +#define NV01_RENDER_SOLID_LINE_POLYLINE__ESIZE 0x00000004 +#define NV01_RENDER_SOLID_LINE_POLYLINE__LEN 0x00000020 +#define NV01_RENDER_SOLID_LINE_POLYLINE_X__MASK 0x0000ffff +#define NV01_RENDER_SOLID_LINE_POLYLINE_X__SHIFT 0 +#define NV01_RENDER_SOLID_LINE_POLYLINE_Y__MASK 0xffff0000 +#define NV01_RENDER_SOLID_LINE_POLYLINE_Y__SHIFT 16 + +#define NV01_RENDER_SOLID_LINE_POLYLINE32_POINT_X(i0) (0x00000580 + 0x8*(i0)) +#define NV01_RENDER_SOLID_LINE_POLYLINE32_POINT_X__ESIZE 0x00000008 +#define NV01_RENDER_SOLID_LINE_POLYLINE32_POINT_X__LEN 0x00000010 + +#define NV01_RENDER_SOLID_LINE_POLYLINE32_POINT_Y(i0) (0x00000584 + 0x8*(i0)) +#define NV01_RENDER_SOLID_LINE_POLYLINE32_POINT_Y__ESIZE 0x00000008 +#define NV01_RENDER_SOLID_LINE_POLYLINE32_POINT_Y__LEN 0x00000010 + +#define NV01_RENDER_SOLID_LINE_CPOLYLINE_COLOR(i0) (0x00000600 + 0x8*(i0)) +#define NV01_RENDER_SOLID_LINE_CPOLYLINE_COLOR__ESIZE 0x00000008 +#define NV01_RENDER_SOLID_LINE_CPOLYLINE_COLOR__LEN 0x00000010 + +#define NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT(i0) (0x00000604 + 0x8*(i0)) +#define NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT__ESIZE 0x00000008 +#define NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT__LEN 0x00000010 +#define NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT_X__MASK 0x0000ffff +#define NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT_X__SHIFT 0 +#define NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT_Y__MASK 0xffff0000 +#define NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT_Y__SHIFT 16 + + +#define NV01_RENDER_SOLID_TRIANGLE_PATCH 0x0000010c + +#define NV01_RENDER_SOLID_TRIANGLE_DMA_NOTIFY 0x00000180 + +#define NV01_RENDER_SOLID_TRIANGLE_CLIP_RECTANGLE 0x00000184 + +#define NV01_RENDER_SOLID_TRIANGLE_PATTERN 0x00000188 + +#define NV04_RENDER_SOLID_TRIANGLE_PATTERN 0x00000188 + +#define NV01_RENDER_SOLID_TRIANGLE_ROP 0x0000018c + +#define NV01_RENDER_SOLID_TRIANGLE_BETA1 0x00000190 + +#define NV01_RENDER_SOLID_TRIANGLE_SURFACE_DST 0x00000194 + + +#define NV04_RENDER_SOLID_TRIANGLE_BETA4 0x00000194 + +#define NV04_RENDER_SOLID_TRIANGLE_SURFACE 0x00000198 + +#define NV01_RENDER_SOLID_TRIANGLE_OPERATION 0x000002fc +#define NV01_RENDER_SOLID_TRIANGLE_OPERATION_SRCCOPY_AND 0x00000000 +#define NV01_RENDER_SOLID_TRIANGLE_OPERATION_ROP_AND 0x00000001 +#define NV01_RENDER_SOLID_TRIANGLE_OPERATION_BLEND_AND 0x00000002 +#define NV01_RENDER_SOLID_TRIANGLE_OPERATION_SRCCOPY 0x00000003 +#define NV01_RENDER_SOLID_TRIANGLE_OPERATION_SRCCOPY_PREMULT 0x00000004 +#define NV01_RENDER_SOLID_TRIANGLE_OPERATION_BLEND_PREMULT 0x00000005 + +#define NV01_RENDER_SOLID_TRIANGLE_COLOR_FORMAT 0x00000300 +#define NV01_RENDER_SOLID_TRIANGLE_COLOR_FORMAT_A16R5G6B5 0x00000001 +#define NV01_RENDER_SOLID_TRIANGLE_COLOR_FORMAT_X16A1R5G5B5 0x00000002 +#define NV01_RENDER_SOLID_TRIANGLE_COLOR_FORMAT_A8R8G8B8 0x00000003 + +#define NV01_RENDER_SOLID_TRIANGLE_COLOR 0x00000304 + +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT0 0x00000310 +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT0_X__MASK 0x0000ffff +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT0_X__SHIFT 0 +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT0_Y__MASK 0xffff0000 +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT0_Y__SHIFT 16 + +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT1 0x00000314 +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT1_X__MASK 0x0000ffff +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT1_X__SHIFT 0 +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT1_Y__MASK 0xffff0000 +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT1_Y__SHIFT 16 + +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT2 0x00000318 +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT2_X__MASK 0x0000ffff +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT2_X__SHIFT 0 +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT2_Y__MASK 0xffff0000 +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT2_Y__SHIFT 16 + +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT0_X 0x00000320 + +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT0_Y 0x00000324 + +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT1_X 0x00000328 + +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT1_Y 0x0000032c + +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT2_X 0x00000330 + +#define NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT2_Y 0x00000334 + +#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH(i0) (0x00000400 + 0x4*(i0)) +#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH__ESIZE 0x00000004 +#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH__LEN 0x00000020 +#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH_X__MASK 0x0000ffff +#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH_X__SHIFT 0 +#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH_Y__MASK 0xffff0000 +#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH_Y__SHIFT 16 + +#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH32_POINT_X(i0) (0x00000480 + 0x8*(i0)) +#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH32_POINT_X__ESIZE 0x00000008 +#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH32_POINT_X__LEN 0x00000010 + +#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH32_POINT_Y(i0) (0x00000484 + 0x8*(i0)) +#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH32_POINT_Y__ESIZE 0x00000008 +#define NV01_RENDER_SOLID_TRIANGLE_TRIMESH32_POINT_Y__LEN 0x00000010 + +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_COLOR(i0) (0x00000500 + 0x10*(i0)) +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_COLOR__ESIZE 0x00000010 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_COLOR__LEN 0x00000008 + +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0(i0) (0x00000504 + 0x10*(i0)) +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0__ESIZE 0x00000010 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0__LEN 0x00000008 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0_X__MASK 0x0000ffff +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0_X__SHIFT 0 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0_Y__MASK 0xffff0000 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0_Y__SHIFT 16 + +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1(i0) (0x00000508 + 0x10*(i0)) +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1__ESIZE 0x00000010 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1__LEN 0x00000008 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1_X__MASK 0x0000ffff +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1_X__SHIFT 0 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1_Y__MASK 0xffff0000 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1_Y__SHIFT 16 + +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2(i0) (0x0000050c + 0x10*(i0)) +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2__ESIZE 0x00000010 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2__LEN 0x00000008 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2_X__MASK 0x0000ffff +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2_X__SHIFT 0 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2_Y__MASK 0xffff0000 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2_Y__SHIFT 16 + +#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_COLOR(i0) (0x00000580 + 0x8*(i0)) +#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_COLOR__ESIZE 0x00000008 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_COLOR__LEN 0x00000010 + +#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT(i0) (0x00000584 + 0x8*(i0)) +#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT__ESIZE 0x00000008 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT__LEN 0x00000010 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT_X__MASK 0x0000ffff +#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT_X__SHIFT 0 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT_Y__MASK 0xffff0000 +#define NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT_Y__SHIFT 16 + + +#define NV01_RENDER_SOLID_RECTANGLE_PATCH 0x0000010c + +#define NV01_RENDER_SOLID_RECTANGLE_DMA_NOTIFY 0x00000180 + +#define NV01_RENDER_SOLID_RECTANGLE_CLIP_RECTANGLE 0x00000184 + +#define NV01_RENDER_SOLID_RECTANGLE_PATTERN 0x00000188 + +#define NV04_RENDER_SOLID_RECTANGLE_PATTERN 0x00000188 + +#define NV01_RENDER_SOLID_RECTANGLE_ROP 0x0000018c + +#define NV01_RENDER_SOLID_RECTANGLE_BETA1 0x00000190 + +#define NV01_RENDER_SOLID_RECTANGLE_SURFACE_DST 0x00000194 + + +#define NV04_RENDER_SOLID_RECTANGLE_BETA4 0x00000194 + +#define NV04_RENDER_SOLID_RECTANGLE_SURFACE 0x00000198 + +#define NV01_RENDER_SOLID_RECTANGLE_OPERATION 0x000002fc +#define NV01_RENDER_SOLID_RECTANGLE_OPERATION_SRCCOPY_AND 0x00000000 +#define NV01_RENDER_SOLID_RECTANGLE_OPERATION_ROP_AND 0x00000001 +#define NV01_RENDER_SOLID_RECTANGLE_OPERATION_BLEND_AND 0x00000002 +#define NV01_RENDER_SOLID_RECTANGLE_OPERATION_SRCCOPY 0x00000003 +#define NV01_RENDER_SOLID_RECTANGLE_OPERATION_SRCCOPY_PREMULT 0x00000004 +#define NV01_RENDER_SOLID_RECTANGLE_OPERATION_BLEND_PREMULT 0x00000005 + +#define NV01_RENDER_SOLID_RECTANGLE_COLOR_FORMAT 0x00000300 +#define NV01_RENDER_SOLID_RECTANGLE_COLOR_FORMAT_A16R5G6B5 0x00000001 +#define NV01_RENDER_SOLID_RECTANGLE_COLOR_FORMAT_X16A1R5G5B5 0x00000002 +#define NV01_RENDER_SOLID_RECTANGLE_COLOR_FORMAT_A8R8G8B8 0x00000003 + +#define NV01_RENDER_SOLID_RECTANGLE_COLOR 0x00000304 + +#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT(i0) (0x00000400 + 0x8*(i0)) +#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT__ESIZE 0x00000008 +#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT__LEN 0x00000010 +#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT_X__MASK 0x0000ffff +#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT_X__SHIFT 0 +#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT_Y__MASK 0xffff0000 +#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT_Y__SHIFT 16 + +#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE(i0) (0x00000404 + 0x8*(i0)) +#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE__ESIZE 0x00000008 +#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE__LEN 0x00000010 +#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE_W__MASK 0x0000ffff +#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE_W__SHIFT 0 +#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE_H__MASK 0xffff0000 +#define NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE_H__SHIFT 16 + + +#define NV01_IMAGE_BLIT_PATCH 0x0000010c + + +#define NV11_IMAGE_BLIT_WAIT_FOR_IDLE 0x00000108 + +#define NV11_IMAGE_BLIT_FLIP_SET_READ 0x00000120 + +#define NV11_IMAGE_BLIT_FLIP_SET_WRITE 0x00000124 + +#define NV11_IMAGE_BLIT_FLIP_MAX 0x00000128 + +#define NV11_IMAGE_BLIT_FLIP_INCR_WRITE 0x0000012c + +#define NV11_IMAGE_BLIT_FLIP_WAIT 0x00000130 + +#define NV11_IMAGE_BLIT_FLIP_CRTC_INCR_READ 0x00000134 + +#define NV01_IMAGE_BLIT_DMA_NOTIFY 0x00000180 + +#define NV01_IMAGE_BLIT_COLOR_KEY 0x00000184 + +#define NV04_IMAGE_BLIT_COLOR_KEY 0x00000184 + +#define NV01_IMAGE_BLIT_CLIP_RECTANGLE 0x00000188 + +#define NV01_IMAGE_BLIT_PATTERN 0x0000018c + +#define NV04_IMAGE_BLIT_PATTERN 0x0000018c + +#define NV01_IMAGE_BLIT_ROP 0x00000190 + +#define NV01_IMAGE_BLIT_BETA1 0x00000194 + + +#define NV01_IMAGE_BLIT_SURFACE_SRC 0x00000198 + +#define NV01_IMAGE_BLIT_SURFACE_DST 0x0000019c + + +#define NV04_IMAGE_BLIT_BETA4 0x00000198 + +#define NV04_IMAGE_BLIT_SURFACES 0x0000019c + +#define NV01_IMAGE_BLIT_OPERATION 0x000002fc +#define NV01_IMAGE_BLIT_OPERATION_SRCCOPY_AND 0x00000000 +#define NV01_IMAGE_BLIT_OPERATION_ROP_AND 0x00000001 +#define NV01_IMAGE_BLIT_OPERATION_BLEND_AND 0x00000002 +#define NV01_IMAGE_BLIT_OPERATION_SRCCOPY 0x00000003 +#define NV01_IMAGE_BLIT_OPERATION_SRCCOPY_PREMULT 0x00000004 +#define NV01_IMAGE_BLIT_OPERATION_BLEND_PREMULT 0x00000005 + +#define NV01_IMAGE_BLIT_POINT_IN 0x00000300 +#define NV01_IMAGE_BLIT_POINT_IN_X__MASK 0x0000ffff +#define NV01_IMAGE_BLIT_POINT_IN_X__SHIFT 0 +#define NV01_IMAGE_BLIT_POINT_IN_Y__MASK 0xffff0000 +#define NV01_IMAGE_BLIT_POINT_IN_Y__SHIFT 16 + +#define NV01_IMAGE_BLIT_POINT_OUT 0x00000304 +#define NV01_IMAGE_BLIT_POINT_OUT_X__MASK 0x0000ffff +#define NV01_IMAGE_BLIT_POINT_OUT_X__SHIFT 0 +#define NV01_IMAGE_BLIT_POINT_OUT_Y__MASK 0xffff0000 +#define NV01_IMAGE_BLIT_POINT_OUT_Y__SHIFT 16 + +#define NV01_IMAGE_BLIT_SIZE 0x00000308 +#define NV01_IMAGE_BLIT_SIZE_W__MASK 0x0000ffff +#define NV01_IMAGE_BLIT_SIZE_W__SHIFT 0 +#define NV01_IMAGE_BLIT_SIZE_H__MASK 0xffff0000 +#define NV01_IMAGE_BLIT_SIZE_H__SHIFT 16 + + +#define NV04_INDEXED_IMAGE_FROM_CPU_PATCH 0x0000010c + +#define NV04_INDEXED_IMAGE_FROM_CPU_DMA_NOTIFY 0x00000180 + +#define NV04_INDEXED_IMAGE_FROM_CPU_DMA_LUT 0x00000184 + +#define NV04_INDEXED_IMAGE_FROM_CPU_COLOR_KEY 0x00000188 + +#define NV04_INDEXED_IMAGE_FROM_CPU_CLIP_RECTANGLE 0x0000018c + +#define NV04_INDEXED_IMAGE_FROM_CPU_PATTERN 0x00000190 + +#define NV04_INDEXED_IMAGE_FROM_CPU_ROP 0x00000194 + +#define NV04_INDEXED_IMAGE_FROM_CPU_BETA1 0x00000198 + +#define NV04_INDEXED_IMAGE_FROM_CPU_BETA4 0x0000019c + +#define NV04_INDEXED_IMAGE_FROM_CPU_SURFACE 0x000001a0 + +#define NV05_INDEXED_IMAGE_FROM_CPU_SURFACE 0x000001a0 + +#define NV05_INDEXED_IMAGE_FROM_CPU_COLOR_CONVERSION 0x000003e0 + +#define NV04_INDEXED_IMAGE_FROM_CPU_OPERATION 0x000003e4 + +#define NV04_INDEXED_IMAGE_FROM_CPU_COLOR_FORMAT 0x000003e8 + +#define NV04_INDEXED_IMAGE_FROM_CPU_INDEX_FORMAT 0x000003ec + +#define NV04_INDEXED_IMAGE_FROM_CPU_LUT_OFFSET 0x000003f0 + +#define NV04_INDEXED_IMAGE_FROM_CPU_POINT 0x000003f4 + +#define NV04_INDEXED_IMAGE_FROM_CPU_SIZE_OUT 0x000003f8 + +#define NV04_INDEXED_IMAGE_FROM_CPU_SIZE_IN 0x000003fc + +#define NV04_INDEXED_IMAGE_FROM_CPU_COLOR(i0) (0x00000400 + 0x4*(i0)) +#define NV04_INDEXED_IMAGE_FROM_CPU_COLOR__ESIZE 0x00000004 +#define NV04_INDEXED_IMAGE_FROM_CPU_COLOR__LEN 0x00000700 + + +#define NV10_IMAGE_FROM_CPU_WAIT_FOR_IDLE 0x00000108 + +#define NV01_IMAGE_FROM_CPU_PATCH 0x0000010c + +#define NV01_IMAGE_FROM_CPU_DMA_NOTIFY 0x00000180 + +#define NV01_IMAGE_FROM_CPU_COLOR_KEY 0x00000184 + +#define NV04_IMAGE_FROM_CPU_COLOR_KEY 0x00000184 + +#define NV01_IMAGE_FROM_CPU_CLIP_RECTANGLE 0x00000188 + +#define NV01_IMAGE_FROM_CPU_PATTERN 0x0000018c + +#define NV04_IMAGE_FROM_CPU_PATTERN 0x0000018c + +#define NV01_IMAGE_FROM_CPU_ROP 0x00000190 + +#define NV01_IMAGE_FROM_CPU_BETA1 0x00000194 + + +#define NV01_IMAGE_FROM_CPU_SURFACE_DST 0x00000198 + + +#define NV04_IMAGE_FROM_CPU_BETA4 0x00000198 + +#define NV04_IMAGE_FROM_CPU_SURFACE 0x0000019c + +#define NV05_IMAGE_FROM_CPU_COLOR_CONVERSION 0x000002f8 + +#define NV01_IMAGE_FROM_CPU_OPERATION 0x000002fc +#define NV01_IMAGE_FROM_CPU_OPERATION_SRCCOPY_AND 0x00000000 +#define NV01_IMAGE_FROM_CPU_OPERATION_ROP_AND 0x00000001 +#define NV01_IMAGE_FROM_CPU_OPERATION_BLEND_AND 0x00000002 +#define NV01_IMAGE_FROM_CPU_OPERATION_SRCCOPY 0x00000003 +#define NV01_IMAGE_FROM_CPU_OPERATION_SRCCOPY_PREMULT 0x00000004 +#define NV01_IMAGE_FROM_CPU_OPERATION_BLEND_PREMULT 0x00000005 + +#define NV01_IMAGE_FROM_CPU_COLOR_FORMAT 0x00000300 +#define NV01_IMAGE_FROM_CPU_COLOR_FORMAT_R5G6G5 0x00000001 +#define NV01_IMAGE_FROM_CPU_COLOR_FORMAT_A1R5G5B5 0x00000002 +#define NV01_IMAGE_FROM_CPU_COLOR_FORMAT_X1R5G5B5 0x00000003 +#define NV01_IMAGE_FROM_CPU_COLOR_FORMAT_A8R8G8B8 0x00000004 +#define NV01_IMAGE_FROM_CPU_COLOR_FORMAT_X8R8G8B8 0x00000005 + +#define NV01_IMAGE_FROM_CPU_POINT 0x00000304 +#define NV01_IMAGE_FROM_CPU_POINT_X__MASK 0x0000ffff +#define NV01_IMAGE_FROM_CPU_POINT_X__SHIFT 0 +#define NV01_IMAGE_FROM_CPU_POINT_Y__MASK 0xffff0000 +#define NV01_IMAGE_FROM_CPU_POINT_Y__SHIFT 16 + +#define NV01_IMAGE_FROM_CPU_SIZE_OUT 0x00000308 +#define NV01_IMAGE_FROM_CPU_SIZE_OUT_W__MASK 0x0000ffff +#define NV01_IMAGE_FROM_CPU_SIZE_OUT_W__SHIFT 0 +#define NV01_IMAGE_FROM_CPU_SIZE_OUT_H__MASK 0xffff0000 +#define NV01_IMAGE_FROM_CPU_SIZE_OUT_H__SHIFT 16 + +#define NV01_IMAGE_FROM_CPU_SIZE_IN 0x0000030c +#define NV01_IMAGE_FROM_CPU_SIZE_IN_W__MASK 0x0000ffff +#define NV01_IMAGE_FROM_CPU_SIZE_IN_W__SHIFT 0 +#define NV01_IMAGE_FROM_CPU_SIZE_IN_H__MASK 0xffff0000 +#define NV01_IMAGE_FROM_CPU_SIZE_IN_H__SHIFT 16 + +#define NV01_IMAGE_FROM_CPU_COLOR(i0) (0x00000400 + 0x4*(i0)) +#define NV01_IMAGE_FROM_CPU_COLOR__ESIZE 0x00000004 +#define NV01_IMAGE_FROM_CPU_COLOR__LEN 0x00000020 + +#define NV04_IMAGE_FROM_CPU_COLOR(i0) (0x00000400 + 0x4*(i0)) +#define NV04_IMAGE_FROM_CPU_COLOR__ESIZE 0x00000004 +#define NV04_IMAGE_FROM_CPU_COLOR__LEN 0x00000700 + + +#define NV03_STRETCHED_IMAGE_FROM_CPU_PATCH 0x0000010c + +#define NV03_STRETCHED_IMAGE_FROM_CPU_DMA_NOTIFY 0x00000180 + +#define NV03_STRETCHED_IMAGE_FROM_CPU_COLOR_KEY 0x00000184 + +#define NV04_STRETCHED_IMAGE_FROM_CPU_COLOR_KEY 0x00000184 + +#define NV03_STRETCHED_IMAGE_FROM_CPU_PATTERN 0x00000188 + +#define NV04_STRETCHED_IMAGE_FROM_CPU_PATTERN 0x00000188 + +#define NV03_STRETCHED_IMAGE_FROM_CPU_ROP 0x0000018c + +#define NV03_STRETCHED_IMAGE_FROM_CPU_BETA1 0x00000190 + + +#define NV03_STRETCHED_IMAGE_FROM_CPU_SURFACE_DST 0x00000194 + + +#define NV04_STRETCHED_IMAGE_FROM_CPU_BETA4 0x00000194 + +#define NV04_STRETCHED_IMAGE_FROM_CPU_SURFACE 0x00000198 + +#define NV05_STRETCHED_IMAGE_FROM_CPU_COLOR_CONVERSION 0x000002f8 + +#define NV03_STRETCHED_IMAGE_FROM_CPU_OPERATION 0x000002fc + +#define NV03_STRETCHED_IMAGE_FROM_CPU_COLOR_FORMAT 0x00000300 + +#define NV03_STRETCHED_IMAGE_FROM_CPU_SIZE_IN 0x00000304 +#define NV03_STRETCHED_IMAGE_FROM_CPU_SIZE_IN_W__MASK 0x0000ffff +#define NV03_STRETCHED_IMAGE_FROM_CPU_SIZE_IN_W__SHIFT 0 +#define NV03_STRETCHED_IMAGE_FROM_CPU_SIZE_IN_H__MASK 0xffff0000 +#define NV03_STRETCHED_IMAGE_FROM_CPU_SIZE_IN_H__SHIFT 16 + +#define NV03_STRETCHED_IMAGE_FROM_CPU_DX_DU 0x00000308 + +#define NV03_STRETCHED_IMAGE_FROM_CPU_DY_DV 0x0000030c + +#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_POINT 0x00000310 +#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_POINT_X__MASK 0x0000ffff +#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_POINT_X__SHIFT 0 +#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_POINT_Y__MASK 0xffff0000 +#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_POINT_Y__SHIFT 16 + +#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_SIZE 0x00000314 +#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_SIZE_W__MASK 0x0000ffff +#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_SIZE_W__SHIFT 0 +#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_SIZE_H__MASK 0xffff0000 +#define NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_SIZE_H__SHIFT 16 + +#define NV03_STRETCHED_IMAGE_FROM_CPU_POINT12D4 0x00000318 +#define NV03_STRETCHED_IMAGE_FROM_CPU_POINT12D4_X__MASK 0x0000ffff +#define NV03_STRETCHED_IMAGE_FROM_CPU_POINT12D4_X__SHIFT 0 +#define NV03_STRETCHED_IMAGE_FROM_CPU_POINT12D4_Y__MASK 0xffff0000 +#define NV03_STRETCHED_IMAGE_FROM_CPU_POINT12D4_Y__SHIFT 16 + +#define NV03_STRETCHED_IMAGE_FROM_CPU_COLOR(i0) (0x00000400 + 0x4*(i0)) +#define NV03_STRETCHED_IMAGE_FROM_CPU_COLOR__ESIZE 0x00000004 +#define NV03_STRETCHED_IMAGE_FROM_CPU_COLOR__LEN 0x00000700 + + +#define NV10_SCALED_IMAGE_FROM_MEMORY_WAIT_FOR_IDLE 0x00000108 + +#define NV03_SCALED_IMAGE_FROM_MEMORY_DMA_NOTIFY 0x00000180 + +#define NV03_SCALED_IMAGE_FROM_MEMORY_DMA_IMAGE 0x00000184 + +#define NV03_SCALED_IMAGE_FROM_MEMORY_PATTERN 0x00000188 + +#define NV04_SCALED_IMAGE_FROM_MEMORY_PATTERN 0x00000188 + +#define NV03_SCALED_IMAGE_FROM_MEMORY_ROP 0x0000018c + +#define NV03_SCALED_IMAGE_FROM_MEMORY_BETA1 0x00000190 + + +#define NV03_SCALED_IMAGE_FROM_MEMORY_SURFACE_DST 0x00000194 + + +#define NV04_SCALED_IMAGE_FROM_MEMORY_BETA4 0x00000194 + +#define NV04_SCALED_IMAGE_FROM_MEMORY_SURFACE 0x00000198 + +#define NV05_SCALED_IMAGE_FROM_MEMORY_SURFACE 0x00000198 + +#define NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION 0x000002fc +#define NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_DITHER 0x00000000 +#define NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_TRUNCATE 0x00000001 +#define NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_SUBTR_TRUNCATE 0x00000002 + +#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT 0x00000300 +#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_A1R5G5B5 0x00000001 +#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_X1R5G5B5 0x00000002 +#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_A8R8G8B8 0x00000003 +#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_X8R8G8B8 0x00000004 +#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_V8YB8U8YA8 0x00000005 +#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_YB8V8YA8U8 0x00000006 +#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_R5G6B5 0x00000007 +#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_Y8 0x00000008 +#define NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_AY8 0x00000009 + +#define NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION 0x00000304 +#define NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_SRCCOPY_AND 0x00000000 +#define NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_ROP_AND 0x00000001 +#define NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_BLEND_AND 0x00000002 +#define NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_SRCCOPY 0x00000003 +#define NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_SRCCOPY_PREMULT 0x00000004 +#define NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_BLEND_PREMULT 0x00000005 + +#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_POINT 0x00000308 +#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_POINT_X__MASK 0x0000ffff +#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_POINT_X__SHIFT 0 +#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_POINT_Y__MASK 0xffff0000 +#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_POINT_Y__SHIFT 16 + +#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_SIZE 0x0000030c +#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_SIZE_W__MASK 0x0000ffff +#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_SIZE_W__SHIFT 0 +#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_SIZE_H__MASK 0xffff0000 +#define NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_SIZE_H__SHIFT 16 + +#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_POINT 0x00000310 +#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_POINT_X__MASK 0x0000ffff +#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_POINT_X__SHIFT 0 +#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_POINT_Y__MASK 0xffff0000 +#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_POINT_Y__SHIFT 16 + +#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_SIZE 0x00000314 +#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_SIZE_W__MASK 0x0000ffff +#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_SIZE_W__SHIFT 0 +#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_SIZE_H__MASK 0xffff0000 +#define NV03_SCALED_IMAGE_FROM_MEMORY_OUT_SIZE_H__SHIFT 16 + +#define NV03_SCALED_IMAGE_FROM_MEMORY_DU_DX 0x00000318 + +#define NV03_SCALED_IMAGE_FROM_MEMORY_DV_DY 0x0000031c + +#define NV03_SCALED_IMAGE_FROM_MEMORY_SIZE 0x00000400 +#define NV03_SCALED_IMAGE_FROM_MEMORY_SIZE_W__MASK 0x0000ffff +#define NV03_SCALED_IMAGE_FROM_MEMORY_SIZE_W__SHIFT 0 +#define NV03_SCALED_IMAGE_FROM_MEMORY_SIZE_H__MASK 0xffff0000 +#define NV03_SCALED_IMAGE_FROM_MEMORY_SIZE_H__SHIFT 16 + +#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT 0x00000404 +#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_PITCH__MASK 0x0000ffff +#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_PITCH__SHIFT 0 +#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN__MASK 0x00ff0000 +#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN__SHIFT 16 +#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN_CENTER 0x00010000 +#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN_CORNER 0x00020000 +#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER__MASK 0xff000000 +#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER__SHIFT 24 +#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER_POINT_SAMPLE 0x00000000 +#define NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER_BILINEAR 0x01000000 + +#define NV03_SCALED_IMAGE_FROM_MEMORY_OFFSET 0x00000408 + +#define NV03_SCALED_IMAGE_FROM_MEMORY_POINT 0x0000040c +#define NV03_SCALED_IMAGE_FROM_MEMORY_POINT_U__MASK 0x0000ffff +#define NV03_SCALED_IMAGE_FROM_MEMORY_POINT_U__SHIFT 0 +#define NV03_SCALED_IMAGE_FROM_MEMORY_POINT_V__MASK 0xffff0000 +#define NV03_SCALED_IMAGE_FROM_MEMORY_POINT_V__SHIFT 16 + + +#define NV50_SCALED_IMAGE_FROM_MEMORY_OFFSET_HIGH 0x00000410 + +#define NV50_SCALED_IMAGE_FROM_MEMORY_SRC_LINEAR 0x00000414 + +#define NV50_SCALED_IMAGE_FROM_MEMORY_SRC_TILE_MODE 0x00000418 + + +#define NV03_GDI_RECTANGLE_TEXT_DMA_NOTIFY 0x00000180 + +#define NV03_GDI_RECTANGLE_TEXT_PATTERN 0x00000184 + +#define NV03_GDI_RECTANGLE_TEXT_ROP 0x00000188 + +#define NV03_GDI_RECTANGLE_TEXT_BETA1 0x0000019c + +#define NV03_GDI_RECTANGLE_TEXT_SURFACE_DST 0x00000190 + +#define NV03_GDI_RECTANGLE_TEXT_OPERATION 0x000002fc + +#define NV03_GDI_RECTANGLE_TEXT_COLOR_FORMAT 0x00000300 + +#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT 0x00000304 + +#define NV03_GDI_RECTANGLE_TEXT_COLOR1_A 0x000003fc + +#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT 0x00000400 +#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_Y__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_Y__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_X__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_X__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE 0x00000404 +#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_H__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_H__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_W__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_W__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT0_B 0x000007f4 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT0_B_L__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT0_B_L__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT0_B_T__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT0_B_T__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT1_B 0x000007f8 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT1_B_R__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT1_B_R__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT1_B_B__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_POINT1_B_B__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_COLOR1_B 0x000007fc + +#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0 0x00000800 +#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_L__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_L__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_T__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_T__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1 0x00000804 +#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_R__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_R__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_B__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_B__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT0 0x00000bec +#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_L__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_L__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_T__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_T__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT1 0x00000bf0 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_R__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_R__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_B__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_B__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_COLOR1_C 0x00000bf4 + +#define NV03_GDI_RECTANGLE_TEXT_SIZE_C 0x00000bf8 +#define NV03_GDI_RECTANGLE_TEXT_SIZE_C_W__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_SIZE_C_W__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_SIZE_C_H__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_SIZE_C_H__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_POINT_C 0x00000bfc +#define NV03_GDI_RECTANGLE_TEXT_POINT_C_X__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_POINT_C_X__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_POINT_C_Y__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_POINT_C_Y__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_C(i0) (0x00000c00 + 0x4*(i0)) +#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_C__ESIZE 0x00000004 +#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_C__LEN 0x00000020 + +#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT0 0x00000fe8 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT0_L__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT0_L__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT0_T__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT0_T__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT1 0x00000fec +#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT1_R__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT1_R__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT1_B__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT1_B__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_COLOR1_D 0x00000ff0 + +#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_D 0x00000ff4 +#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_D_W__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_D_W__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_D_H__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_D_H__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_D 0x00000ff8 +#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_D_W__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_D_W__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_D_H__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_D_H__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_POINT_D 0x00000ffc +#define NV03_GDI_RECTANGLE_TEXT_POINT_D_X__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_POINT_D_X__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_POINT_D_Y__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_POINT_D_Y__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_D(i0) (0x00001000 + 0x4*(i0)) +#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_D__ESIZE 0x00000004 +#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_D__LEN 0x00000020 + +#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT0 0x000013e4 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_L__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_L__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_T__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_T__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT1 0x000013e8 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_R__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_R__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_B__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_B__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_COLOR0_E 0x000013ec + +#define NV03_GDI_RECTANGLE_TEXT_COLOR1_E 0x000013f0 + +#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_E 0x000013f4 +#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_E_W__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_E_W__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_E_H__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_SIZE_IN_E_H__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_E 0x000013f8 +#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_E_W__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_E_W__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_E_H__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_E_H__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_POINT_E 0x000013fc +#define NV03_GDI_RECTANGLE_TEXT_POINT_E_X__MASK 0x0000ffff +#define NV03_GDI_RECTANGLE_TEXT_POINT_E_X__SHIFT 0 +#define NV03_GDI_RECTANGLE_TEXT_POINT_E_Y__MASK 0xffff0000 +#define NV03_GDI_RECTANGLE_TEXT_POINT_E_Y__SHIFT 16 + +#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR01_E(i0) (0x00001400 + 0x4*(i0)) +#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR01_E__ESIZE 0x00000004 +#define NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR01_E__LEN 0x00000020 + + +#define NV04_GDI_RECTANGLE_TEXT_PATCH 0x0000010c + +#define NV04_GDI_RECTANGLE_TEXT_DMA_NOTIFY 0x00000180 + +#define NV04_GDI_RECTANGLE_TEXT_DMA_FONTS 0x00000184 + +#define NV04_GDI_RECTANGLE_TEXT_PATTERN 0x00000188 + +#define NV04_GDI_RECTANGLE_TEXT_ROP 0x0000018c + +#define NV04_GDI_RECTANGLE_TEXT_BETA1 0x00000190 + +#define NV04_GDI_RECTANGLE_TEXT_BETA4 0x00000194 + +#define NV04_GDI_RECTANGLE_TEXT_SURFACE 0x00000198 + +#define NV04_GDI_RECTANGLE_TEXT_OPERATION 0x000002fc +#define NV04_GDI_RECTANGLE_TEXT_OPERATION_SRCCOPY_AND 0x00000000 +#define NV04_GDI_RECTANGLE_TEXT_OPERATION_ROP_AND 0x00000001 +#define NV04_GDI_RECTANGLE_TEXT_OPERATION_BLEND_AND 0x00000002 +#define NV04_GDI_RECTANGLE_TEXT_OPERATION_SRCCOPY 0x00000003 +#define NV04_GDI_RECTANGLE_TEXT_OPERATION_SRCCOPY_PREMULT 0x00000004 +#define NV04_GDI_RECTANGLE_TEXT_OPERATION_BLEND_PREMULT 0x00000005 + +#define NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT 0x00000300 +#define NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A16R5G6B5 0x00000001 +#define NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_X16A1R5G5B5 0x00000002 +#define NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A8R8G8B8 0x00000003 + +#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT 0x00000304 +#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT_CGA6 0x00000001 +#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT_LE 0x00000002 + +#define NV04_GDI_RECTANGLE_TEXT_COLOR1_A 0x000003fc + +#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT(i0) (0x00000400 + 0x8*(i0)) +#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT__ESIZE 0x00000008 +#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT__LEN 0x00000020 +#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_Y__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_Y__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_X__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_X__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE(i0) (0x00000404 + 0x8*(i0)) +#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE__ESIZE 0x00000008 +#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE__LEN 0x00000020 +#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_H__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_H__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_W__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_W__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT0 0x000005f4 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT0_L__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT0_L__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT0_T__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT0_T__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT1 0x000005f8 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT1_R__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT1_R__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT1_B__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT1_B__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_COLOR1_B 0x000005fc + +#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0(i0) (0x00000600 + 0x8*(i0)) +#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0__ESIZE 0x00000008 +#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0__LEN 0x00000020 +#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_L__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_L__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_T__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_T__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1(i0) (0x00000604 + 0x8*(i0)) +#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1__ESIZE 0x00000008 +#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1__LEN 0x00000020 +#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_R__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_R__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_B__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_B__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT0 0x000007ec +#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_L__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_L__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_T__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_T__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT1 0x000007f0 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_R__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_R__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_B__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_B__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_COLOR1_C 0x000007f4 + +#define NV04_GDI_RECTANGLE_TEXT_SIZE_C 0x000007f8 +#define NV04_GDI_RECTANGLE_TEXT_SIZE_C_W__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_SIZE_C_W__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_SIZE_C_H__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_SIZE_C_H__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_POINT_C 0x000007fc +#define NV04_GDI_RECTANGLE_TEXT_POINT_C_X__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_POINT_C_X__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_POINT_C_Y__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_POINT_C_Y__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_C(i0) (0x00000800 + 0x4*(i0)) +#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_C__ESIZE 0x00000004 +#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_C__LEN 0x00000080 + +#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT0 0x00000be4 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_L__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_L__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_T__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_T__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT1 0x00000be8 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_R__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_R__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_B__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_B__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_COLOR0_E 0x00000bec + +#define NV04_GDI_RECTANGLE_TEXT_COLOR1_E 0x00000bf0 + +#define NV04_GDI_RECTANGLE_TEXT_SIZE_IN_E 0x00000bf4 +#define NV04_GDI_RECTANGLE_TEXT_SIZE_IN_E_W__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_SIZE_IN_E_W__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_SIZE_IN_E_H__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_SIZE_IN_E_H__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_SIZE_OUT_E 0x00000bf8 +#define NV04_GDI_RECTANGLE_TEXT_SIZE_OUT_E_W__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_SIZE_OUT_E_W__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_SIZE_OUT_E_H__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_SIZE_OUT_E_H__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_POINT_E 0x00000bfc +#define NV04_GDI_RECTANGLE_TEXT_POINT_E_X__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_POINT_E_X__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_POINT_E_Y__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_POINT_E_Y__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR01_E(i0) (0x00000c00 + 0x4*(i0)) +#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR01_E__ESIZE 0x00000004 +#define NV04_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR01_E__LEN 0x00000080 + +#define NV04_GDI_RECTANGLE_TEXT_FONT_F 0x00000ff0 +#define NV04_GDI_RECTANGLE_TEXT_FONT_F_OFFSET__MASK 0x0fffffff +#define NV04_GDI_RECTANGLE_TEXT_FONT_F_OFFSET__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_FONT_F_PITCH__MASK 0xf0000000 +#define NV04_GDI_RECTANGLE_TEXT_FONT_F_PITCH__SHIFT 28 + +#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT0 0x00000ff4 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT0_L__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT0_L__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT0_T__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT0_T__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT1 0x00000ff8 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT1_R__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT1_R__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT1_B__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT1_B__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_COLOR1_F 0x00000ffc + +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F(i0) (0x00001000 + 0x4*(i0)) +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F__ESIZE 0x00000004 +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F__LEN 0x00000100 +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_INDEX__MASK 0x000000ff +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_INDEX__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_X__MASK 0x000fff00 +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_X__SHIFT 8 +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_Y__MASK 0xfff00000 +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_Y__SHIFT 20 + +#define NV04_GDI_RECTANGLE_TEXT_FONT_G 0x000017f0 +#define NV04_GDI_RECTANGLE_TEXT_FONT_G_OFFSET__MASK 0x0fffffff +#define NV04_GDI_RECTANGLE_TEXT_FONT_G_OFFSET__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_FONT_G_PITCH__MASK 0xf0000000 +#define NV04_GDI_RECTANGLE_TEXT_FONT_G_PITCH__SHIFT 28 + +#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT0 0x000017f4 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT0_L__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT0_L__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT0_T__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT0_T__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT1 0x000017f8 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT1_R__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT1_R__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT1_B__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT1_B__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_COLOR1_G 0x000017fc + +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT(i0) (0x00001800 + 0x8*(i0)) +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT__ESIZE 0x00000008 +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT__LEN 0x00000100 +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT_X__MASK 0x0000ffff +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT_X__SHIFT 0 +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT_Y__MASK 0xffff0000 +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT_Y__SHIFT 16 + +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_INDEX(i0) (0x00001804 + 0x8*(i0)) +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_INDEX__ESIZE 0x00000008 +#define NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_INDEX__LEN 0x00000100 + + +#define NV10_TEXTURE_FROM_CPU_WAIT_FOR_IDLE 0x00000108 + +#define NV10_TEXTURE_FROM_CPU_DMA_NOTIFY 0x00000180 + +#define NV10_TEXTURE_FROM_CPU_SURFACE 0x00000184 + +#define NV10_TEXTURE_FROM_CPU_COLOR_FORMAT 0x00000300 + +#define NV10_TEXTURE_FROM_CPU_POINT 0x00000304 +#define NV10_TEXTURE_FROM_CPU_POINT_X__MASK 0x0000ffff +#define NV10_TEXTURE_FROM_CPU_POINT_X__SHIFT 0 +#define NV10_TEXTURE_FROM_CPU_POINT_Y__MASK 0xffff0000 +#define NV10_TEXTURE_FROM_CPU_POINT_Y__SHIFT 16 + +#define NV10_TEXTURE_FROM_CPU_SIZE 0x00000308 +#define NV10_TEXTURE_FROM_CPU_SIZE_W__MASK 0x0000ffff +#define NV10_TEXTURE_FROM_CPU_SIZE_W__SHIFT 0 +#define NV10_TEXTURE_FROM_CPU_SIZE_H__MASK 0xffff0000 +#define NV10_TEXTURE_FROM_CPU_SIZE_H__SHIFT 16 + +#define NV10_TEXTURE_FROM_CPU_CLIP_HORIZONTAL 0x0000030c +#define NV10_TEXTURE_FROM_CPU_CLIP_HORIZONTAL_X__MASK 0x0000ffff +#define NV10_TEXTURE_FROM_CPU_CLIP_HORIZONTAL_X__SHIFT 0 +#define NV10_TEXTURE_FROM_CPU_CLIP_HORIZONTAL_W__MASK 0xffff0000 +#define NV10_TEXTURE_FROM_CPU_CLIP_HORIZONTAL_W__SHIFT 16 + +#define NV10_TEXTURE_FROM_CPU_CLIP_VERTICAL 0x00000310 +#define NV10_TEXTURE_FROM_CPU_CLIP_VERTICAL_Y__MASK 0x0000ffff +#define NV10_TEXTURE_FROM_CPU_CLIP_VERTICAL_Y__SHIFT 0 +#define NV10_TEXTURE_FROM_CPU_CLIP_VERTICAL_H__MASK 0xffff0000 +#define NV10_TEXTURE_FROM_CPU_CLIP_VERTICAL_H__SHIFT 16 + +#define NV10_TEXTURE_FROM_CPU_COLOR(i0) (0x00000400 + 0x4*(i0)) +#define NV10_TEXTURE_FROM_CPU_COLOR__ESIZE 0x00000004 +#define NV10_TEXTURE_FROM_CPU_COLOR__LEN 0x00000700 + + +#endif /* NV01_2D_XML */ diff --git a/src/mesa/drivers/dri/nouveau/nv04_3d.xml.h b/src/mesa/drivers/dri/nouveau/nv04_3d.xml.h new file mode 100644 index 0000000000..d4fb680a36 --- /dev/null +++ b/src/mesa/drivers/dri/nouveau/nv04_3d.xml.h @@ -0,0 +1,738 @@ +#ifndef NV04_3D_XML +#define NV04_3D_XML + +/* Autogenerated file, DO NOT EDIT manually! + +This file was generated by the rules-ng-ng headergen tool in this git repository: +http://0x04.net/cgit/index.cgi/rules-ng-ng +git clone git://0x04.net/rules-ng-ng + +The rules-ng-ng source files this header was generated from are: +- nv04_3d.xml ( 17839 bytes, from 2010-11-15 02:23:48) +- copyright.xml ( 6452 bytes, from 2010-11-15 15:10:58) +- nv_object.xml ( 11547 bytes, from 2010-11-13 23:32:57) +- nvchipsets.xml ( 3074 bytes, from 2010-11-13 23:32:57) +- nv_defs.xml ( 4437 bytes, from 2010-11-01 00:28:46) +- nv_3ddefs.xml ( 16394 bytes, from 2010-11-01 00:28:46) + +Copyright (C) 2006-2010 by the following authors: +- Artur Huillet <arthur.huillet@free.fr> (ahuillet) +- Ben Skeggs (darktama, darktama_) +- B. R. <koala_br@users.sourceforge.net> (koala_br) +- Carlos Martin <carlosmn@users.sf.net> (carlosmn) +- Christoph Bumiller <e0425955@student.tuwien.ac.at> (calim, chrisbmr) +- Dawid Gajownik <gajownik@users.sf.net> (gajownik) +- Dmitry Baryshkov +- Dmitry Eremin-Solenikov <lumag@users.sf.net> (lumag) +- EdB <edb_@users.sf.net> (edb_) +- Erik Waling <erikwailing@users.sf.net> (erikwaling) +- Francisco Jerez <currojerez@riseup.net> (curro) +- imirkin <imirkin@users.sf.net> (imirkin) +- jb17bsome <jb17bsome@bellsouth.net> (jb17bsome) +- Jeremy Kolb <kjeremy@users.sf.net> (kjeremy) +- Laurent Carlier <lordheavym@gmail.com> (lordheavy) +- Luca Barbieri <luca@luca-barbieri.com> (lb, lb1) +- Maarten Maathuis <madman2003@gmail.com> (stillunknown) +- Marcin Kościelnicki <koriakin@0x04.net> (mwk, koriakin) +- Mark Carey <mark.carey@gmail.com> (careym) +- Matthieu Castet <matthieu.castet@parrot.com> (mat-c) +- nvidiaman <nvidiaman@users.sf.net> (nvidiaman) +- Patrice Mandin <patmandin@gmail.com> (pmandin, pmdata) +- Pekka Paalanen <pq@iki.fi> (pq, ppaalanen) +- Peter Popov <ironpeter@users.sf.net> (ironpeter) +- Richard Hughes <hughsient@users.sf.net> (hughsient) +- Rudi Cilibrasi <cilibrar@users.sf.net> (cilibrar) +- Serge Martin +- Simon Raffeiner +- Stephane Loeuillet <leroutier@users.sf.net> (leroutier) +- Stephane Marchesin <stephane.marchesin@gmail.com> (marcheu) +- sturmflut <sturmflut@users.sf.net> (sturmflut) +- Sylvain Munaut <tnt@246tNt.com> +- Victor Stinner <victor.stinner@haypocalc.com> (haypo) +- Wladmir van der Laan <laanwj@gmail.com> (miathan6) +- Younes Manton <younes.m@gmail.com> (ymanton) + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial +portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + + + +#define NV04_CONTEXT_SURFACES_3D_DMA_NOTIFY 0x00000180 + +#define NV04_CONTEXT_SURFACES_3D_DMA_COLOR 0x00000184 + +#define NV04_CONTEXT_SURFACES_3D_DMA_ZETA 0x00000188 + +#define NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL 0x000002f8 +#define NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL_X__MASK 0x0000ffff +#define NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL_X__SHIFT 0 +#define NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL_W__MASK 0xffff0000 +#define NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL_W__SHIFT 16 + +#define NV04_CONTEXT_SURFACES_3D_CLIP_VERTICAL 0x000002fc +#define NV04_CONTEXT_SURFACES_3D_CLIP_VERTICAL_Y__MASK 0x0000ffff +#define NV04_CONTEXT_SURFACES_3D_CLIP_VERTICAL_Y__SHIFT 0 +#define NV04_CONTEXT_SURFACES_3D_CLIP_VERTICAL_H__MASK 0xffff0000 +#define NV04_CONTEXT_SURFACES_3D_CLIP_VERTICAL_H__SHIFT 16 + +#define NV04_CONTEXT_SURFACES_3D_FORMAT 0x00000300 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR__MASK 0x000000ff +#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR__SHIFT 0 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X1R5G5B5_Z1R5G5B5 0x00000001 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X1R5G5B5_X1R5G5B5 0x00000002 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_R5G6B5 0x00000003 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X8R8G8B8_Z8R8G8B8 0x00000004 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X8R8G8B8_X8R8G8B8 0x00000005 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X1A7R8G8B8_Z1A7R8G8B8 0x00000006 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X1A7R8G8B8_X1A7R8G8B8 0x00000007 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_A8R8G8B8 0x00000008 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_TYPE__MASK 0x0000ff00 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_TYPE__SHIFT 8 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_TYPE_PITCH 0x00000100 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_TYPE_SWIZZLE 0x00000200 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_BASE_SIZE_U__MASK 0x00ff0000 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_BASE_SIZE_U__SHIFT 16 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_BASE_SIZE_V__MASK 0xff000000 +#define NV04_CONTEXT_SURFACES_3D_FORMAT_BASE_SIZE_V__SHIFT 24 + +#define NV04_CONTEXT_SURFACES_3D_CLIP_SIZE 0x00000304 +#define NV04_CONTEXT_SURFACES_3D_CLIP_SIZE_W__MASK 0x0000ffff +#define NV04_CONTEXT_SURFACES_3D_CLIP_SIZE_W__SHIFT 0 +#define NV04_CONTEXT_SURFACES_3D_CLIP_SIZE_H__MASK 0xffff0000 +#define NV04_CONTEXT_SURFACES_3D_CLIP_SIZE_H__SHIFT 16 + +#define NV04_CONTEXT_SURFACES_3D_PITCH 0x00000308 +#define NV04_CONTEXT_SURFACES_3D_PITCH_COLOR__MASK 0x0000ffff +#define NV04_CONTEXT_SURFACES_3D_PITCH_COLOR__SHIFT 0 +#define NV04_CONTEXT_SURFACES_3D_PITCH_ZETA__MASK 0xffff0000 +#define NV04_CONTEXT_SURFACES_3D_PITCH_ZETA__SHIFT 16 + +#define NV04_CONTEXT_SURFACES_3D_OFFSET_COLOR 0x0000030c + +#define NV04_CONTEXT_SURFACES_3D_OFFSET_ZETA 0x00000310 + + +#define NV04_TEXTURED_TRIANGLE_DMA_NOTIFY 0x00000180 + +#define NV04_TEXTURED_TRIANGLE_DMA_A 0x00000184 + +#define NV04_TEXTURED_TRIANGLE_DMA_B 0x00000188 + +#define NV04_TEXTURED_TRIANGLE_SURFACES 0x0000018c + +#define NV04_TEXTURED_TRIANGLE_COLORKEY 0x00000300 + +#define NV04_TEXTURED_TRIANGLE_OFFSET 0x00000304 + +#define NV04_TEXTURED_TRIANGLE_FORMAT 0x00000308 +#define NV04_TEXTURED_TRIANGLE_FORMAT_DMA_A 0x00000001 +#define NV04_TEXTURED_TRIANGLE_FORMAT_DMA_B 0x00000002 +#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_KEY_ENABLE 0x00000004 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_ZOH__MASK 0x00000030 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_ZOH__SHIFT 4 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_ZOH_CENTER 0x00000010 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_ZOH_CORNER 0x00000020 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_FOH__MASK 0x000000c0 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_FOH__SHIFT 6 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_FOH_CENTER 0x00000040 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_FOH_CORNER 0x00000080 +#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR__MASK 0x00000f00 +#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR__SHIFT 8 +#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_Y8 0x00000100 +#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_A1R5G5B5 0x00000200 +#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_X1R5G5B5 0x00000300 +#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_A4R4G4B4 0x00000400 +#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_R5G6B5 0x00000500 +#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_A8R8G8B8 0x00000600 +#define NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_X8R8G8B8 0x00000700 +#define NV04_TEXTURED_TRIANGLE_FORMAT_MIPMAP_LEVELS__MASK 0x0000f000 +#define NV04_TEXTURED_TRIANGLE_FORMAT_MIPMAP_LEVELS__SHIFT 12 +#define NV04_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_U__MASK 0x000f0000 +#define NV04_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_U__SHIFT 16 +#define NV04_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_V__MASK 0x00f00000 +#define NV04_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_V__SHIFT 20 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU__MASK 0x07000000 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU__SHIFT 24 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_REPEAT 0x01000000 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_MIRRORED_REPEAT 0x02000000 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_CLAMP_TO_EDGE 0x03000000 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_CLAMP_TO_BORDER 0x04000000 +#define NV04_TEXTURED_TRIANGLE_FORMAT_WRAPU 0x08000000 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV__MASK 0x70000000 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV__SHIFT 28 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_REPEAT 0x10000000 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_MIRRORED_REPEAT 0x20000000 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_CLAMP_TO_EDGE 0x30000000 +#define NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_CLAMP_TO_BORDER 0x40000000 +#define NV04_TEXTURED_TRIANGLE_FORMAT_WRAPV 0x80000000 + +#define NV04_TEXTURED_TRIANGLE_FILTER 0x0000030c +#define NV04_TEXTURED_TRIANGLE_FILTER_KERNEL_SIZE_X__MASK 0x000000ff +#define NV04_TEXTURED_TRIANGLE_FILTER_KERNEL_SIZE_X__SHIFT 0 +#define NV04_TEXTURED_TRIANGLE_FILTER_KERNEL_SIZE_Y__MASK 0x00007f00 +#define NV04_TEXTURED_TRIANGLE_FILTER_KERNEL_SIZE_Y__SHIFT 8 +#define NV04_TEXTURED_TRIANGLE_FILTER_MIPMAP_DITHER_ENABLE 0x00008000 +#define NV04_TEXTURED_TRIANGLE_FILTER_MIPMAP_LODBIAS__MASK 0x00ff0000 +#define NV04_TEXTURED_TRIANGLE_FILTER_MIPMAP_LODBIAS__SHIFT 16 +#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY__MASK 0x07000000 +#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY__SHIFT 24 +#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_NEAREST 0x01000000 +#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_LINEAR 0x02000000 +#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_NEAREST_MIPMAP_NEAREST 0x03000000 +#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_LINEAR_MIPMAP_NEAREST 0x04000000 +#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_NEAREST_MIPMAP_LINEAR 0x05000000 +#define NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_LINEAR_MIPMAP_LINEAR 0x06000000 +#define NV04_TEXTURED_TRIANGLE_FILTER_ANISOTROPIC_MINIFY_ENABLE 0x08000000 +#define NV04_TEXTURED_TRIANGLE_FILTER_MAGNIFY__MASK 0x70000000 +#define NV04_TEXTURED_TRIANGLE_FILTER_MAGNIFY__SHIFT 28 +#define NV04_TEXTURED_TRIANGLE_FILTER_MAGNIFY_NEAREST 0x10000000 +#define NV04_TEXTURED_TRIANGLE_FILTER_MAGNIFY_LINEAR 0x20000000 +#define NV04_TEXTURED_TRIANGLE_FILTER_ANISOTROPIC_MAGNIFY_ENABLE 0x80000000 + +#define NV04_TEXTURED_TRIANGLE_BLEND 0x00000310 +#define NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_MAP__MASK 0x0000000f +#define NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_MAP__SHIFT 0 +#define NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_MAP_DECAL 0x00000001 +#define NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_MAP_MODULATE 0x00000002 +#define NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_MAP_DECALALPHA 0x00000003 +#define NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_MAP_MODULATEALPHA 0x00000004 +#define NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_MAP_DECALMASK 0x00000005 +#define NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_MAP_MODULATEMASK 0x00000006 +#define NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_MAP_COPY 0x00000007 +#define NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_MAP_ADD 0x00000008 +#define NV04_TEXTURED_TRIANGLE_BLEND_MASK_BIT__MASK 0x00000030 +#define NV04_TEXTURED_TRIANGLE_BLEND_MASK_BIT__SHIFT 4 +#define NV04_TEXTURED_TRIANGLE_BLEND_MASK_BIT_LSB 0x00000010 +#define NV04_TEXTURED_TRIANGLE_BLEND_MASK_BIT_MSB 0x00000020 +#define NV04_TEXTURED_TRIANGLE_BLEND_SHADE_MODE__MASK 0x000000c0 +#define NV04_TEXTURED_TRIANGLE_BLEND_SHADE_MODE__SHIFT 6 +#define NV04_TEXTURED_TRIANGLE_BLEND_SHADE_MODE_FLAT 0x00000040 +#define NV04_TEXTURED_TRIANGLE_BLEND_SHADE_MODE_GOURAUD 0x00000080 +#define NV04_TEXTURED_TRIANGLE_BLEND_SHADE_MODE_PHONG 0x000000c0 +#define NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_PERSPECTIVE_ENABLE 0x00000100 +#define NV04_TEXTURED_TRIANGLE_BLEND_SPECULAR_ENABLE 0x00001000 +#define NV04_TEXTURED_TRIANGLE_BLEND_FOG_ENABLE 0x00010000 +#define NV04_TEXTURED_TRIANGLE_BLEND_BLEND_ENABLE 0x00100000 +#define NV04_TEXTURED_TRIANGLE_BLEND_SRC__MASK 0x0f000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_SRC__SHIFT 24 +#define NV04_TEXTURED_TRIANGLE_BLEND_SRC_ZERO 0x01000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_SRC_ONE 0x02000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_SRC_SRC_COLOR 0x03000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_SRC_ONE_MINUS_SRC_COLOR 0x04000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_SRC_SRC_ALPHA 0x05000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_SRC_ONE_MINUS_SRC_ALPHA 0x06000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_SRC_DST_ALPHA 0x07000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_SRC_ONE_MINUS_DST_ALPHA 0x08000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_SRC_DST_COLOR 0x09000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_SRC_ONE_MINUS_DST_COLOR 0x0a000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_SRC_SRC_ALPHA_SATURATE 0x0b000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_DST__MASK 0xf0000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_DST__SHIFT 28 +#define NV04_TEXTURED_TRIANGLE_BLEND_DST_ZERO 0x10000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_DST_ONE 0x20000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_DST_SRC_COLOR 0x30000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_DST_ONE_MINUS_SRC_COLOR 0x40000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_DST_SRC_ALPHA 0x50000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_DST_ONE_MINUS_SRC_ALPHA 0x60000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_DST_DST_ALPHA 0x70000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_DST_ONE_MINUS_DST_ALPHA 0x80000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_DST_DST_COLOR 0x90000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_DST_ONE_MINUS_DST_COLOR 0xa0000000 +#define NV04_TEXTURED_TRIANGLE_BLEND_DST_SRC_ALPHA_SATURATE 0xb0000000 + +#define NV04_TEXTURED_TRIANGLE_CONTROL 0x00000314 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_REF__MASK 0x000000ff +#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_REF__SHIFT 0 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_FUNC__MASK 0x00000f00 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_FUNC__SHIFT 8 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_FUNC_NEVER 0x00000100 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_FUNC_LESS 0x00000200 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_FUNC_EQUAL 0x00000300 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_FUNC_LEQUAL 0x00000400 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_FUNC_GREATER 0x00000500 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_FUNC_NOTEQUAL 0x00000600 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_FUNC_GEQUAL 0x00000700 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_FUNC_ALWAYS 0x00000800 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_ENABLE 0x00001000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ORIGIN__MASK 0x00002000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ORIGIN__SHIFT 13 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ORIGIN_CENTER 0x00000000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_ORIGIN_CORNER 0x00002000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_ENABLE 0x00004000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FUNC__MASK 0x000f0000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FUNC__SHIFT 16 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FUNC_NEVER 0x00010000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FUNC_LESS 0x00020000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FUNC_EQUAL 0x00030000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FUNC_LEQUAL 0x00040000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FUNC_GREATER 0x00050000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FUNC_NOTEQUAL 0x00060000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FUNC_GEQUAL 0x00070000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FUNC_ALWAYS 0x00080000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE__MASK 0x00300000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE__SHIFT 20 +#define NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_BOTH 0x00000000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_NONE 0x00100000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_CW 0x00200000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_CCW 0x00300000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_DITHER_ENABLE 0x00400000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_PERSPECTIVE_ENABLE 0x00800000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_WRITE 0x01000000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FORMAT__MASK 0xc0000000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FORMAT__SHIFT 30 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FORMAT_FIXED 0x40000000 +#define NV04_TEXTURED_TRIANGLE_CONTROL_Z_FORMAT_FLOAT 0x80000000 + +#define NV04_TEXTURED_TRIANGLE_FOGCOLOR 0x00000318 +#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_B__MASK 0x000000ff +#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_B__SHIFT 0 +#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_G__MASK 0x0000ff00 +#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_G__SHIFT 8 +#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_R__MASK 0x00ff0000 +#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_R__SHIFT 16 +#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_A__MASK 0xff000000 +#define NV04_TEXTURED_TRIANGLE_FOGCOLOR_A__SHIFT 24 + +#define NV04_TEXTURED_TRIANGLE_TLVERTEX(i0) (0x00000400 + 0x20*(i0)) +#define NV04_TEXTURED_TRIANGLE_TLVERTEX__ESIZE 0x00000020 +#define NV04_TEXTURED_TRIANGLE_TLVERTEX__LEN 0x00000010 + +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SX(i0) (0x00000400 + 0x20*(i0)) + +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SY(i0) (0x00000404 + 0x20*(i0)) + +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SZ(i0) (0x00000408 + 0x20*(i0)) + +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_RHW(i0) (0x0000040c + 0x20*(i0)) + +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR(i0) (0x00000410 + 0x20*(i0)) +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_B__MASK 0x000000ff +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_B__SHIFT 0 +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_G__MASK 0x0000ff00 +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_G__SHIFT 8 +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_R__MASK 0x00ff0000 +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_R__SHIFT 16 +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_A__MASK 0xff000000 +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_A__SHIFT 24 + +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR(i0) (0x00000414 + 0x20*(i0)) +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_B__MASK 0x000000ff +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_B__SHIFT 0 +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_G__MASK 0x0000ff00 +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_G__SHIFT 8 +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_R__MASK 0x00ff0000 +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_R__SHIFT 16 +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_FOG__MASK 0xff000000 +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_FOG__SHIFT 24 + +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_TU(i0) (0x00000418 + 0x20*(i0)) + +#define NV04_TEXTURED_TRIANGLE_TLVERTEX_TV(i0) (0x0000041c + 0x20*(i0)) + +#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE(i0) (0x00000600 + 0x4*(i0)) +#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE__ESIZE 0x00000004 +#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE__LEN 0x00000040 +#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I0__MASK 0x0000000f +#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I0__SHIFT 0 +#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I1__MASK 0x000000f0 +#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I1__SHIFT 4 +#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I2__MASK 0x00000f00 +#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I2__SHIFT 8 +#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I3__MASK 0x0000f000 +#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I3__SHIFT 12 +#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I4__MASK 0x000f0000 +#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I4__SHIFT 16 +#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I5__MASK 0x00f00000 +#define NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I5__SHIFT 20 + + +#define NV04_MULTITEX_TRIANGLE_DMA_NOTIFY 0x00000180 + +#define NV04_MULTITEX_TRIANGLE_DMA_A 0x00000184 + +#define NV04_MULTITEX_TRIANGLE_DMA_B 0x00000188 + +#define NV04_MULTITEX_TRIANGLE_SURFACES 0x0000018c + +#define NV04_MULTITEX_TRIANGLE_OFFSET(i0) (0x00000308 + 0x4*(i0)) +#define NV04_MULTITEX_TRIANGLE_OFFSET__ESIZE 0x00000004 +#define NV04_MULTITEX_TRIANGLE_OFFSET__LEN 0x00000002 + +#define NV04_MULTITEX_TRIANGLE_FORMAT(i0) (0x00000310 + 0x4*(i0)) +#define NV04_MULTITEX_TRIANGLE_FORMAT__ESIZE 0x00000004 +#define NV04_MULTITEX_TRIANGLE_FORMAT__LEN 0x00000002 +#define NV04_MULTITEX_TRIANGLE_FORMAT_DMA_A 0x00000001 +#define NV04_MULTITEX_TRIANGLE_FORMAT_DMA_B 0x00000002 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_ZOH__MASK 0x00000030 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_ZOH__SHIFT 4 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_ZOH_CENTER 0x00000010 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_ZOH_CORNER 0x00000020 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_FOH__MASK 0x000000c0 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_FOH__SHIFT 6 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_FOH_CENTER 0x00000040 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_FOH_CORNER 0x00000080 +#define NV04_MULTITEX_TRIANGLE_FORMAT_COLOR__MASK 0x00000f00 +#define NV04_MULTITEX_TRIANGLE_FORMAT_COLOR__SHIFT 8 +#define NV04_MULTITEX_TRIANGLE_FORMAT_COLOR_Y8 0x00000100 +#define NV04_MULTITEX_TRIANGLE_FORMAT_COLOR_A1R5G5B5 0x00000200 +#define NV04_MULTITEX_TRIANGLE_FORMAT_COLOR_X1R5G5B5 0x00000300 +#define NV04_MULTITEX_TRIANGLE_FORMAT_COLOR_A4R4G4B4 0x00000400 +#define NV04_MULTITEX_TRIANGLE_FORMAT_COLOR_R5G6B5 0x00000500 +#define NV04_MULTITEX_TRIANGLE_FORMAT_COLOR_A8R8G8B8 0x00000600 +#define NV04_MULTITEX_TRIANGLE_FORMAT_COLOR_X8R8G8B8 0x00000700 +#define NV04_MULTITEX_TRIANGLE_FORMAT_MIPMAP_LEVELS__MASK 0x0000f000 +#define NV04_MULTITEX_TRIANGLE_FORMAT_MIPMAP_LEVELS__SHIFT 12 +#define NV04_MULTITEX_TRIANGLE_FORMAT_BASE_SIZE_U__MASK 0x000f0000 +#define NV04_MULTITEX_TRIANGLE_FORMAT_BASE_SIZE_U__SHIFT 16 +#define NV04_MULTITEX_TRIANGLE_FORMAT_BASE_SIZE_V__MASK 0x00f00000 +#define NV04_MULTITEX_TRIANGLE_FORMAT_BASE_SIZE_V__SHIFT 20 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSU__MASK 0x07000000 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSU__SHIFT 24 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSU_REPEAT 0x01000000 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSU_MIRRORED_REPEAT 0x02000000 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSU_CLAMP_TO_EDGE 0x03000000 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSU_CLAMP_TO_BORDER 0x04000000 +#define NV04_MULTITEX_TRIANGLE_FORMAT_WRAPU 0x08000000 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSV__MASK 0x70000000 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSV__SHIFT 28 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSV_REPEAT 0x10000000 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSV_MIRRORED_REPEAT 0x20000000 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSV_CLAMP_TO_EDGE 0x30000000 +#define NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSV_CLAMP_TO_BORDER 0x40000000 +#define NV04_MULTITEX_TRIANGLE_FORMAT_WRAPV 0x80000000 + +#define NV04_MULTITEX_TRIANGLE_FILTER(i0) (0x00000318 + 0x4*(i0)) +#define NV04_MULTITEX_TRIANGLE_FILTER__ESIZE 0x00000004 +#define NV04_MULTITEX_TRIANGLE_FILTER__LEN 0x00000002 +#define NV04_MULTITEX_TRIANGLE_FILTER_KERNEL_SIZE_X__MASK 0x000000ff +#define NV04_MULTITEX_TRIANGLE_FILTER_KERNEL_SIZE_X__SHIFT 0 +#define NV04_MULTITEX_TRIANGLE_FILTER_KERNEL_SIZE_Y__MASK 0x00007f00 +#define NV04_MULTITEX_TRIANGLE_FILTER_KERNEL_SIZE_Y__SHIFT 8 +#define NV04_MULTITEX_TRIANGLE_FILTER_MIPMAP_DITHER_ENABLE 0x00008000 +#define NV04_MULTITEX_TRIANGLE_FILTER_MIPMAP_LODBIAS__MASK 0x00ff0000 +#define NV04_MULTITEX_TRIANGLE_FILTER_MIPMAP_LODBIAS__SHIFT 16 +#define NV04_MULTITEX_TRIANGLE_FILTER_MINIFY__MASK 0x07000000 +#define NV04_MULTITEX_TRIANGLE_FILTER_MINIFY__SHIFT 24 +#define NV04_MULTITEX_TRIANGLE_FILTER_MINIFY_NEAREST 0x01000000 +#define NV04_MULTITEX_TRIANGLE_FILTER_MINIFY_LINEAR 0x02000000 +#define NV04_MULTITEX_TRIANGLE_FILTER_MINIFY_NEAREST_MIPMAP_NEAREST 0x03000000 +#define NV04_MULTITEX_TRIANGLE_FILTER_MINIFY_LINEAR_MIPMAP_NEAREST 0x04000000 +#define NV04_MULTITEX_TRIANGLE_FILTER_MINIFY_NEAREST_MIPMAP_LINEAR 0x05000000 +#define NV04_MULTITEX_TRIANGLE_FILTER_MINIFY_LINEAR_MIPMAP_LINEAR 0x06000000 +#define NV04_MULTITEX_TRIANGLE_FILTER_ANISOTROPIC_MINIFY_ENABLE 0x08000000 +#define NV04_MULTITEX_TRIANGLE_FILTER_MAGNIFY__MASK 0x70000000 +#define NV04_MULTITEX_TRIANGLE_FILTER_MAGNIFY__SHIFT 28 +#define NV04_MULTITEX_TRIANGLE_FILTER_MAGNIFY_NEAREST 0x10000000 +#define NV04_MULTITEX_TRIANGLE_FILTER_MAGNIFY_LINEAR 0x20000000 +#define NV04_MULTITEX_TRIANGLE_FILTER_ANISOTROPIC_MAGNIFY_ENABLE 0x80000000 + +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA(i0) (0x00000320 + 0xc*(i0)) +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA__ESIZE 0x0000000c +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA__LEN 0x00000002 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_INVERSE0 0x00000001 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0__MASK 0x000000fc +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0__SHIFT 2 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_ZERO 0x00000004 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_CONSTANT 0x00000008 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_PRIMARY_COLOR 0x0000000c +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_PREVIOUS 0x00000010 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_TEXTURE0 0x00000014 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_TEXTURE1 0x00000018 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_TEXTURELOD 0x0000001c +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_INVERSE1 0x00000100 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1__MASK 0x0000fc00 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1__SHIFT 10 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_ZERO 0x00000400 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_CONSTANT 0x00000800 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_PRIMARY_COLOR 0x00000c00 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_PREVIOUS 0x00001000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_TEXTURE0 0x00001400 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_TEXTURE1 0x00001800 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_TEXTURELOD 0x00001c00 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_INVERSE2 0x00010000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2__MASK 0x00fc0000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2__SHIFT 18 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_ZERO 0x00040000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_CONSTANT 0x00080000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_PRIMARY_COLOR 0x000c0000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_PREVIOUS 0x00100000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_TEXTURE0 0x00140000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_TEXTURE1 0x00180000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_TEXTURELOD 0x001c0000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_INVERSE3 0x01000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3__MASK 0x1c000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3__SHIFT 26 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_ZERO 0x04000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_CONSTANT 0x08000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_PRIMARY_COLOR 0x0c000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_PREVIOUS 0x10000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_TEXTURE0 0x14000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_TEXTURE1 0x18000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_TEXTURELOD 0x1c000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP__MASK 0xe0000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP__SHIFT 29 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_IDENTITY 0x20000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_SCALE2 0x40000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_SCALE4 0x60000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_BIAS 0x80000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_BIAS_SCALE2 0xe0000000 + +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR(i0) (0x00000324 + 0xc*(i0)) +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR__ESIZE 0x0000000c +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR__LEN 0x00000002 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_INVERSE0 0x00000001 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ALPHA0 0x00000002 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0__MASK 0x000000fc +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0__SHIFT 2 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_ZERO 0x00000004 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_CONSTANT 0x00000008 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_PRIMARY_COLOR 0x0000000c +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_PREVIOUS 0x00000010 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_TEXTURE0 0x00000014 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_TEXTURE1 0x00000018 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_TEXTURELOD 0x0000001c +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_INVERSE1 0x00000100 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ALPHA1 0x00000200 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1__MASK 0x0000fc00 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1__SHIFT 10 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_ZERO 0x00000400 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_CONSTANT 0x00000800 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_PRIMARY_COLOR 0x00000c00 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_PREVIOUS 0x00001000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_TEXTURE0 0x00001400 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_TEXTURE1 0x00001800 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_TEXTURELOD 0x00001c00 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_INVERSE2 0x00010000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ALPHA2 0x00020000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2__MASK 0x00fc0000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2__SHIFT 18 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_ZERO 0x00040000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_CONSTANT 0x00080000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_PRIMARY_COLOR 0x000c0000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_PREVIOUS 0x00100000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_TEXTURE0 0x00140000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_TEXTURE1 0x00180000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_TEXTURELOD 0x001c0000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_INVERSE3 0x01000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ALPHA3 0x02000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3__MASK 0x1c000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3__SHIFT 26 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_ZERO 0x04000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_CONSTANT 0x08000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_PRIMARY_COLOR 0x0c000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_PREVIOUS 0x10000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_TEXTURE0 0x14000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_TEXTURE1 0x18000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_TEXTURELOD 0x1c000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP__MASK 0xe0000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP__SHIFT 29 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_IDENTITY 0x20000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_SCALE2 0x40000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_SCALE4 0x60000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_BIAS 0x80000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_BIAS_SCALE2 0xe0000000 + +#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR 0x00000334 +#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_B__MASK 0x000000ff +#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_B__SHIFT 0 +#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_G__MASK 0x0000ff00 +#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_G__SHIFT 8 +#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_R__MASK 0x00ff0000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_R__SHIFT 16 +#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_A__MASK 0xff000000 +#define NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_A__SHIFT 24 + +#define NV04_MULTITEX_TRIANGLE_BLEND 0x00000338 +#define NV04_MULTITEX_TRIANGLE_BLEND_MASK_BIT__MASK 0x00000030 +#define NV04_MULTITEX_TRIANGLE_BLEND_MASK_BIT__SHIFT 4 +#define NV04_MULTITEX_TRIANGLE_BLEND_MASK_BIT_LSB 0x00000010 +#define NV04_MULTITEX_TRIANGLE_BLEND_MASK_BIT_MSB 0x00000020 +#define NV04_MULTITEX_TRIANGLE_BLEND_SHADE_MODE__MASK 0x000000c0 +#define NV04_MULTITEX_TRIANGLE_BLEND_SHADE_MODE__SHIFT 6 +#define NV04_MULTITEX_TRIANGLE_BLEND_SHADE_MODE_FLAT 0x00000040 +#define NV04_MULTITEX_TRIANGLE_BLEND_SHADE_MODE_GOURAUD 0x00000080 +#define NV04_MULTITEX_TRIANGLE_BLEND_SHADE_MODE_PHONG 0x000000c0 +#define NV04_MULTITEX_TRIANGLE_BLEND_TEXTURE_PERSPECTIVE_ENABLE 0x00000100 +#define NV04_MULTITEX_TRIANGLE_BLEND_SPECULAR_ENABLE 0x00001000 +#define NV04_MULTITEX_TRIANGLE_BLEND_FOG_ENABLE 0x00010000 +#define NV04_MULTITEX_TRIANGLE_BLEND_BLEND_ENABLE 0x00100000 +#define NV04_MULTITEX_TRIANGLE_BLEND_SRC__MASK 0x0f000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_SRC__SHIFT 24 +#define NV04_MULTITEX_TRIANGLE_BLEND_SRC_ZERO 0x01000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_SRC_ONE 0x02000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_SRC_SRC_COLOR 0x03000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_SRC_ONE_MINUS_SRC_COLOR 0x04000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_SRC_SRC_ALPHA 0x05000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_SRC_ONE_MINUS_SRC_ALPHA 0x06000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_SRC_DST_ALPHA 0x07000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_SRC_ONE_MINUS_DST_ALPHA 0x08000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_SRC_DST_COLOR 0x09000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_SRC_ONE_MINUS_DST_COLOR 0x0a000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_SRC_SRC_ALPHA_SATURATE 0x0b000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_DST__MASK 0xf0000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_DST__SHIFT 28 +#define NV04_MULTITEX_TRIANGLE_BLEND_DST_ZERO 0x10000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_DST_ONE 0x20000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_DST_SRC_COLOR 0x30000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_DST_ONE_MINUS_SRC_COLOR 0x40000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_DST_SRC_ALPHA 0x50000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_DST_ONE_MINUS_SRC_ALPHA 0x60000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_DST_DST_ALPHA 0x70000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_DST_ONE_MINUS_DST_ALPHA 0x80000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_DST_DST_COLOR 0x90000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_DST_ONE_MINUS_DST_COLOR 0xa0000000 +#define NV04_MULTITEX_TRIANGLE_BLEND_DST_SRC_ALPHA_SATURATE 0xb0000000 + +#define NV04_MULTITEX_TRIANGLE_CONTROL0 0x0000033c +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_REF__MASK 0x000000ff +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_REF__SHIFT 0 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_FUNC__MASK 0x00000f00 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_FUNC__SHIFT 8 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_FUNC_NEVER 0x00000100 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_FUNC_LESS 0x00000200 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_FUNC_EQUAL 0x00000300 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_FUNC_LEQUAL 0x00000400 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_FUNC_GREATER 0x00000500 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_FUNC_NOTEQUAL 0x00000600 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_FUNC_GEQUAL 0x00000700 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_FUNC_ALWAYS 0x00000800 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_ENABLE 0x00001000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ORIGIN__MASK 0x00002000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ORIGIN__SHIFT 13 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ORIGIN_CENTER 0x00000000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ORIGIN_CORNER 0x00002000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_ENABLE 0x00004000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FUNC__MASK 0x000f0000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FUNC__SHIFT 16 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FUNC_NEVER 0x00010000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FUNC_LESS 0x00020000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FUNC_EQUAL 0x00030000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FUNC_LEQUAL 0x00040000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FUNC_GREATER 0x00050000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FUNC_NOTEQUAL 0x00060000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FUNC_GEQUAL 0x00070000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FUNC_ALWAYS 0x00080000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE__MASK 0x00300000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE__SHIFT 20 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_BOTH 0x00000000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_NONE 0x00100000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_CW 0x00200000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_CCW 0x00300000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_DITHER_ENABLE 0x00400000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_PERSPECTIVE_ENABLE 0x00800000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_WRITE 0x01000000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_STENCIL_WRITE 0x02000000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_WRITE 0x04000000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_RED_WRITE 0x08000000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_GREEN_WRITE 0x10000000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_BLUE_WRITE 0x20000000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FORMAT__MASK 0xc0000000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FORMAT__SHIFT 30 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FORMAT_FIXED 0x40000000 +#define NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FORMAT_FLOAT 0x80000000 + +#define NV04_MULTITEX_TRIANGLE_CONTROL1 0x00000340 +#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_ENABLE 0x00000001 +#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_FUNC__MASK 0x000000f0 +#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_FUNC__SHIFT 4 +#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_REF__MASK 0x0000ff00 +#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_REF__SHIFT 8 +#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_MASK_READ__MASK 0x00ff0000 +#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_MASK_READ__SHIFT 16 +#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_MASK_WRITE__MASK 0xff000000 +#define NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_MASK_WRITE__SHIFT 24 + +#define NV04_MULTITEX_TRIANGLE_CONTROL2 0x00000344 +#define NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_FAIL__MASK 0x0000000f +#define NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_FAIL__SHIFT 0 +#define NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_ZFAIL__MASK 0x000000f0 +#define NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_ZFAIL__SHIFT 4 +#define NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_ZPASS__MASK 0x00000f00 +#define NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_ZPASS__SHIFT 8 + +#define NV04_MULTITEX_TRIANGLE_FOGCOLOR 0x00000348 +#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_B__MASK 0x000000ff +#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_B__SHIFT 0 +#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_G__MASK 0x0000ff00 +#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_G__SHIFT 8 +#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_R__MASK 0x00ff0000 +#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_R__SHIFT 16 +#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_A__MASK 0xff000000 +#define NV04_MULTITEX_TRIANGLE_FOGCOLOR_A__SHIFT 24 + +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX(i0) (0x00000400 + 0x28*(i0)) +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX__ESIZE 0x00000028 +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX__LEN 0x00000008 + +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SX(i0) (0x00000400 + 0x28*(i0)) + +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SY(i0) (0x00000404 + 0x28*(i0)) + +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SZ(i0) (0x00000408 + 0x28*(i0)) + +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_RHW(i0) (0x0000040c + 0x28*(i0)) + +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR(i0) (0x00000410 + 0x28*(i0)) +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_B__MASK 0x000000ff +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_B__SHIFT 0 +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_G__MASK 0x0000ff00 +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_G__SHIFT 8 +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_R__MASK 0x00ff0000 +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_R__SHIFT 16 +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_A__MASK 0xff000000 +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_A__SHIFT 24 + +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR(i0) (0x00000414 + 0x28*(i0)) +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_B__MASK 0x000000ff +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_B__SHIFT 0 +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_G__MASK 0x0000ff00 +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_G__SHIFT 8 +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_R__MASK 0x00ff0000 +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_R__SHIFT 16 +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_FOG__MASK 0xff000000 +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_FOG__SHIFT 24 + +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TU0(i0) (0x00000418 + 0x28*(i0)) + +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TV0(i0) (0x0000041c + 0x28*(i0)) + +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TU1(i0) (0x00000420 + 0x28*(i0)) + +#define NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TV1(i0) (0x00000424 + 0x28*(i0)) + +#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE(i0) (0x00000540 + 0x4*(i0)) +#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE__ESIZE 0x00000004 +#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE__LEN 0x00000030 +#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I0__MASK 0x0000000f +#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I0__SHIFT 0 +#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I1__MASK 0x000000f0 +#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I1__SHIFT 4 +#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I2__MASK 0x00000f00 +#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I2__SHIFT 8 +#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I3__MASK 0x0000f000 +#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I3__SHIFT 12 +#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I4__MASK 0x000f0000 +#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I4__SHIFT 16 +#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I5__MASK 0x00f00000 +#define NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I5__SHIFT 20 + + +#endif /* NV04_3D_XML */ diff --git a/src/mesa/drivers/dri/nouveau/nv04_context.c b/src/mesa/drivers/dri/nouveau/nv04_context.c index 8683343b39..3140af56fd 100644 --- a/src/mesa/drivers/dri/nouveau/nv04_context.c +++ b/src/mesa/drivers/dri/nouveau/nv04_context.c @@ -28,7 +28,7 @@ #include "nouveau_context.h" #include "nouveau_fbo.h" #include "nouveau_util.h" -#include "nouveau_class.h" +#include "nv04_3d.xml.h" #include "nv04_driver.h" static GLboolean diff --git a/src/mesa/drivers/dri/nouveau/nv04_context.h b/src/mesa/drivers/dri/nouveau/nv04_context.h index 45e70d2bc3..960a6550dc 100644 --- a/src/mesa/drivers/dri/nouveau/nv04_context.h +++ b/src/mesa/drivers/dri/nouveau/nv04_context.h @@ -28,6 +28,7 @@ #define __NV04_CONTEXT_H__ #include "nouveau_context.h" +#include "nv_object.xml.h" struct nv04_context { struct nouveau_context base; diff --git a/src/mesa/drivers/dri/nouveau/nv04_render.c b/src/mesa/drivers/dri/nouveau/nv04_render.c index 47bad24f9d..ad45093edd 100644 --- a/src/mesa/drivers/dri/nouveau/nv04_render.c +++ b/src/mesa/drivers/dri/nouveau/nv04_render.c @@ -27,7 +27,7 @@ #include "nouveau_driver.h" #include "nouveau_context.h" #include "nouveau_util.h" -#include "nouveau_class.h" +#include "nv04_3d.xml.h" #include "nv04_driver.h" #include "tnl/tnl.h" diff --git a/src/mesa/drivers/dri/nouveau/nv04_state_fb.c b/src/mesa/drivers/dri/nouveau/nv04_state_fb.c index a3e343660f..854571d07e 100644 --- a/src/mesa/drivers/dri/nouveau/nv04_state_fb.c +++ b/src/mesa/drivers/dri/nouveau/nv04_state_fb.c @@ -28,7 +28,7 @@ #include "nouveau_context.h" #include "nouveau_fbo.h" #include "nouveau_util.h" -#include "nouveau_class.h" +#include "nv04_3d.xml.h" #include "nv04_driver.h" static inline unsigned @@ -36,11 +36,11 @@ get_rt_format(gl_format format) { switch (format) { case MESA_FORMAT_XRGB8888: - return 0x05; + return NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X8R8G8B8_X8R8G8B8; case MESA_FORMAT_ARGB8888: - return 0x08; + return NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_A8R8G8B8; case MESA_FORMAT_RGB565: - return 0x03; + return NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_R5G6B5; default: assert(0); } diff --git a/src/mesa/drivers/dri/nouveau/nv04_state_frag.c b/src/mesa/drivers/dri/nouveau/nv04_state_frag.c index 658b23a4d9..21478de262 100644 --- a/src/mesa/drivers/dri/nouveau/nv04_state_frag.c +++ b/src/mesa/drivers/dri/nouveau/nv04_state_frag.c @@ -27,12 +27,13 @@ #include "nouveau_driver.h" #include "nouveau_context.h" #include "nouveau_util.h" -#include "nouveau_class.h" +#include "nv_object.xml.h" +#include "nv04_3d.xml.h" #include "nv04_driver.h" #define COMBINER_SHIFT(in) \ - (NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT##in##_SHIFT \ - - NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_SHIFT) + (NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT##in##__SHIFT \ + - NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0__SHIFT) #define COMBINER_SOURCE(reg) \ NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_##reg #define COMBINER_INVERT \ diff --git a/src/mesa/drivers/dri/nouveau/nv04_state_raster.c b/src/mesa/drivers/dri/nouveau/nv04_state_raster.c index a114f44b22..98f2f98f1d 100644 --- a/src/mesa/drivers/dri/nouveau/nv04_state_raster.c +++ b/src/mesa/drivers/dri/nouveau/nv04_state_raster.c @@ -27,7 +27,8 @@ #include "nouveau_driver.h" #include "nouveau_context.h" #include "nouveau_util.h" -#include "nouveau_class.h" +#include "nv_object.xml.h" +#include "nv04_3d.xml.h" #include "nv04_driver.h" static unsigned @@ -142,7 +143,7 @@ nv04_emit_control(struct gl_context *ctx, int emit) int cull_mode = ctx->Polygon.CullFaceMode; int front_face = ctx->Polygon.FrontFace; uint32_t ctrl0 = 1 << 30 | - NV04_MULTITEX_TRIANGLE_CONTROL0_ORIGIN; + NV04_MULTITEX_TRIANGLE_CONTROL0_ORIGIN_CORNER; uint32_t ctrl1 = 0, ctrl2 = 0; /* Color mask. */ @@ -210,7 +211,7 @@ nv04_emit_control(struct gl_context *ctx, int emit) int cull_mode = ctx->Polygon.CullFaceMode; int front_face = ctx->Polygon.FrontFace; uint32_t ctrl = 1 << 30 | - NV04_TEXTURED_TRIANGLE_CONTROL_ORIGIN; + NV04_TEXTURED_TRIANGLE_CONTROL_ORIGIN_CORNER; /* Dithering. */ if (ctx->Color.DitherFlag) diff --git a/src/mesa/drivers/dri/nouveau/nv04_state_tex.c b/src/mesa/drivers/dri/nouveau/nv04_state_tex.c index 1fe47a30e4..5ed8b14755 100644 --- a/src/mesa/drivers/dri/nouveau/nv04_state_tex.c +++ b/src/mesa/drivers/dri/nouveau/nv04_state_tex.c @@ -29,7 +29,8 @@ #include "nouveau_texture.h" #include "nouveau_util.h" #include "nouveau_gldefs.h" -#include "nouveau_class.h" +#include "nv_object.xml.h" +#include "nv04_3d.xml.h" #include "nv04_driver.h" static uint32_t diff --git a/src/mesa/drivers/dri/nouveau/nv04_surface.c b/src/mesa/drivers/dri/nouveau/nv04_surface.c index 6d3ffa26d3..c1eda8b7f3 100644 --- a/src/mesa/drivers/dri/nouveau/nv04_surface.c +++ b/src/mesa/drivers/dri/nouveau/nv04_surface.c @@ -25,7 +25,10 @@ */ #include "nouveau_driver.h" -#include "nouveau_class.h" +#include "nv_object.xml.h" +#include "nv_m2mf.xml.h" +#include "nv01_2d.xml.h" +#include "nv04_3d.xml.h" #include "nouveau_context.h" #include "nouveau_util.h" #include "nv04_driver.h" @@ -283,9 +286,9 @@ nv04_surface_copy_m2mf(struct gl_context *ctx, unsigned dst_offset = dst->offset + dy * dst->pitch + dx * dst->cpp; unsigned src_offset = src->offset + sy * src->pitch + sx * src->cpp; - nouveau_bo_marko(bctx, m2mf, NV04_MEMORY_TO_MEMORY_FORMAT_DMA_BUFFER_IN, + nouveau_bo_marko(bctx, m2mf, NV04_M2MF_DMA_BUFFER_IN, src->bo, bo_flags | NOUVEAU_BO_RD); - nouveau_bo_marko(bctx, m2mf, NV04_MEMORY_TO_MEMORY_FORMAT_DMA_BUFFER_OUT, + nouveau_bo_marko(bctx, m2mf, NV04_M2MF_DMA_BUFFER_OUT, dst->bo, bo_flags | NOUVEAU_BO_WR); while (h) { @@ -293,7 +296,7 @@ nv04_surface_copy_m2mf(struct gl_context *ctx, MARK_RING(chan, 9, 2); - BEGIN_RING(chan, m2mf, NV04_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN, 8); + BEGIN_RING(chan, m2mf, NV04_M2MF_OFFSET_IN, 8); OUT_RELOCl(chan, src->bo, src_offset, bo_flags | NOUVEAU_BO_RD); OUT_RELOCl(chan, dst->bo, dst_offset, @@ -488,12 +491,11 @@ nv04_surface_init(struct gl_context *ctx) goto fail; /* Memory to memory format. */ - ret = nouveau_grobj_alloc(chan, handle++, NV04_MEMORY_TO_MEMORY_FORMAT, - &hw->m2mf); + ret = nouveau_grobj_alloc(chan, handle++, NV04_M2MF, &hw->m2mf); if (ret) goto fail; - BEGIN_RING(chan, hw->m2mf, NV04_MEMORY_TO_MEMORY_FORMAT_DMA_NOTIFY, 1); + BEGIN_RING(chan, hw->m2mf, NV04_M2MF_DMA_NOTIFY, 1); OUT_RING (chan, hw->ntfy->handle); /* Context surfaces 2D. */ diff --git a/src/mesa/drivers/dri/nouveau/nv10_3d.xml.h b/src/mesa/drivers/dri/nouveau/nv10_3d.xml.h new file mode 100644 index 0000000000..cdc61f4573 --- /dev/null +++ b/src/mesa/drivers/dri/nouveau/nv10_3d.xml.h @@ -0,0 +1,1619 @@ +#ifndef NV10_3D_XML +#define NV10_3D_XML + +/* Autogenerated file, DO NOT EDIT manually! + +This file was generated by the rules-ng-ng headergen tool in this git repository: +http://0x04.net/cgit/index.cgi/rules-ng-ng +git clone git://0x04.net/rules-ng-ng + +The rules-ng-ng source files this header was generated from are: +- nv10_3d.xml ( 18437 bytes, from 2010-11-15 15:30:21) +- copyright.xml ( 6452 bytes, from 2010-11-15 15:10:58) +- nv_defs.xml ( 4437 bytes, from 2010-11-01 00:28:46) +- nv_3ddefs.xml ( 16394 bytes, from 2010-11-01 00:28:46) +- nv_object.xml ( 11547 bytes, from 2010-11-13 23:32:57) +- nvchipsets.xml ( 3074 bytes, from 2010-11-13 23:32:57) + +Copyright (C) 2006-2010 by the following authors: +- Artur Huillet <arthur.huillet@free.fr> (ahuillet) +- Ben Skeggs (darktama, darktama_) +- B. R. <koala_br@users.sourceforge.net> (koala_br) +- Carlos Martin <carlosmn@users.sf.net> (carlosmn) +- Christoph Bumiller <e0425955@student.tuwien.ac.at> (calim, chrisbmr) +- Dawid Gajownik <gajownik@users.sf.net> (gajownik) +- Dmitry Baryshkov +- Dmitry Eremin-Solenikov <lumag@users.sf.net> (lumag) +- EdB <edb_@users.sf.net> (edb_) +- Erik Waling <erikwailing@users.sf.net> (erikwaling) +- Francisco Jerez <currojerez@riseup.net> (curro) +- imirkin <imirkin@users.sf.net> (imirkin) +- jb17bsome <jb17bsome@bellsouth.net> (jb17bsome) +- Jeremy Kolb <kjeremy@users.sf.net> (kjeremy) +- Laurent Carlier <lordheavym@gmail.com> (lordheavy) +- Luca Barbieri <luca@luca-barbieri.com> (lb, lb1) +- Maarten Maathuis <madman2003@gmail.com> (stillunknown) +- Marcin Kościelnicki <koriakin@0x04.net> (mwk, koriakin) +- Mark Carey <mark.carey@gmail.com> (careym) +- Matthieu Castet <matthieu.castet@parrot.com> (mat-c) +- nvidiaman <nvidiaman@users.sf.net> (nvidiaman) +- Patrice Mandin <patmandin@gmail.com> (pmandin, pmdata) +- Pekka Paalanen <pq@iki.fi> (pq, ppaalanen) +- Peter Popov <ironpeter@users.sf.net> (ironpeter) +- Richard Hughes <hughsient@users.sf.net> (hughsient) +- Rudi Cilibrasi <cilibrar@users.sf.net> (cilibrar) +- Serge Martin +- Simon Raffeiner +- Stephane Loeuillet <leroutier@users.sf.net> (leroutier) +- Stephane Marchesin <stephane.marchesin@gmail.com> (marcheu) +- sturmflut <sturmflut@users.sf.net> (sturmflut) +- Sylvain Munaut <tnt@246tNt.com> +- Victor Stinner <victor.stinner@haypocalc.com> (haypo) +- Wladmir van der Laan <laanwj@gmail.com> (miathan6) +- Younes Manton <younes.m@gmail.com> (ymanton) + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial +portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + + +#define NV10_VERTEX_ATTR_POS 0x00000000 +#define NV10_VERTEX_ATTR_COLOR0 0x00000001 +#define NV10_VERTEX_ATTR_COLOR1 0x00000002 +#define NV10_VERTEX_ATTR_TEX0 0x00000003 +#define NV10_VERTEX_ATTR_TEX1 0x00000004 +#define NV10_VERTEX_ATTR_NORMAL 0x00000005 +#define NV10_VERTEX_ATTR_WEIGHT 0x00000006 +#define NV10_VERTEX_ATTR_FOG 0x00000007 + + + +#define NV11_3D_FLIP_SET_READ 0x00000120 + +#define NV11_3D_FLIP_SET_WRITE 0x00000124 + +#define NV11_3D_FLIP_MAX 0x00000128 + +#define NV11_3D_FLIP_INCR_WRITE 0x0000012c + +#define NV11_3D_FLIP_WAIT 0x00000130 + +#define NV10_3D_DMA_NOTIFY 0x00000180 + +#define NV10_3D_DMA_TEXTURE0 0x00000184 + +#define NV10_3D_DMA_TEXTURE1 0x00000188 + +#define NV10_3D_DMA_COLOR 0x00000194 + +#define NV10_3D_DMA_ZETA 0x00000198 + +#define NV10_3D_RT_HORIZ 0x00000200 +#define NV10_3D_RT_HORIZ_X__MASK 0x0000ffff +#define NV10_3D_RT_HORIZ_X__SHIFT 0 +#define NV10_3D_RT_HORIZ_W__MASK 0xffff0000 +#define NV10_3D_RT_HORIZ_W__SHIFT 16 + +#define NV10_3D_RT_VERT 0x00000204 +#define NV10_3D_RT_VERT_Y__MASK 0x0000ffff +#define NV10_3D_RT_VERT_Y__SHIFT 0 +#define NV10_3D_RT_VERT_H__MASK 0xffff0000 +#define NV10_3D_RT_VERT_H__SHIFT 16 + +#define NV10_3D_RT_FORMAT 0x00000208 +#define NV10_3D_RT_FORMAT_TYPE__MASK 0x00000f00 +#define NV10_3D_RT_FORMAT_TYPE__SHIFT 8 +#define NV10_3D_RT_FORMAT_TYPE_LINEAR 0x00000100 +#define NV10_3D_RT_FORMAT_TYPE_SWIZZLED 0x00000200 +#define NV10_3D_RT_FORMAT_DEPTH__MASK 0x00000030 +#define NV10_3D_RT_FORMAT_DEPTH__SHIFT 4 +#define NV10_3D_RT_FORMAT_DEPTH_Z24S8 0x00000000 +#define NV10_3D_RT_FORMAT_DEPTH_Z16 0x00000010 +#define NV10_3D_RT_FORMAT_COLOR__MASK 0x0000000f +#define NV10_3D_RT_FORMAT_COLOR__SHIFT 0 +#define NV10_3D_RT_FORMAT_COLOR_R5G6B5 0x00000003 +#define NV10_3D_RT_FORMAT_COLOR_X8R8G8B8 0x00000005 +#define NV10_3D_RT_FORMAT_COLOR_A8R8G8B8 0x00000008 +#define NV10_3D_RT_FORMAT_COLOR_B8 0x00000009 + +#define NV10_3D_RT_PITCH 0x0000020c +#define NV10_3D_RT_PITCH_COLOR_PITCH__MASK 0x0000ffff +#define NV10_3D_RT_PITCH_COLOR_PITCH__SHIFT 0 +#define NV10_3D_RT_PITCH_ZETA_PITCH__MASK 0xffff0000 +#define NV10_3D_RT_PITCH_ZETA_PITCH__SHIFT 16 + +#define NV10_3D_COLOR_OFFSET 0x00000210 + +#define NV10_3D_ZETA_OFFSET 0x00000214 + +#define NV10_3D_UNK0290 0x00000290 + +#define NV10_3D_VIEWPORT_CLIP_MODE 0x000002b4 + +#define NV10_3D_VIEWPORT_CLIP_HORIZ(i0) (0x000002c0 + 0x4*(i0)) +#define NV10_3D_VIEWPORT_CLIP_HORIZ__ESIZE 0x00000004 +#define NV10_3D_VIEWPORT_CLIP_HORIZ__LEN 0x00000008 +#define NV10_3D_VIEWPORT_CLIP_HORIZ_CLIP_L__MASK 0x000007ff +#define NV10_3D_VIEWPORT_CLIP_HORIZ_CLIP_L__SHIFT 0 +#define NV10_3D_VIEWPORT_CLIP_HORIZ_CLIP_LEFT_ENABLE 0x00000800 +#define NV10_3D_VIEWPORT_CLIP_HORIZ_CLIP_R__MASK 0x07ff0000 +#define NV10_3D_VIEWPORT_CLIP_HORIZ_CLIP_R__SHIFT 16 +#define NV10_3D_VIEWPORT_CLIP_HORIZ_CLIP_RIGHT_ENABLE 0x08000000 + +#define NV10_3D_VIEWPORT_CLIP_VERT(i0) (0x000002e0 + 0x4*(i0)) +#define NV10_3D_VIEWPORT_CLIP_VERT__ESIZE 0x00000004 +#define NV10_3D_VIEWPORT_CLIP_VERT__LEN 0x00000008 +#define NV10_3D_VIEWPORT_CLIP_VERT_CLIP_T__MASK 0x000007ff +#define NV10_3D_VIEWPORT_CLIP_VERT_CLIP_T__SHIFT 0 +#define NV10_3D_VIEWPORT_CLIP_VERT_CLIP_TOP_ENABLE 0x00000800 +#define NV10_3D_VIEWPORT_CLIP_VERT_CLIP_B__MASK 0x07ff0000 +#define NV10_3D_VIEWPORT_CLIP_VERT_CLIP_B__SHIFT 16 +#define NV10_3D_VIEWPORT_CLIP_VERT_CLIP_BOTTOM_ENABLE 0x08000000 + +#define NV10_3D_ALPHA_FUNC_ENABLE 0x00000300 + +#define NV10_3D_BLEND_FUNC_ENABLE 0x00000304 + +#define NV10_3D_CULL_FACE_ENABLE 0x00000308 + +#define NV10_3D_DEPTH_TEST_ENABLE 0x0000030c + +#define NV10_3D_DITHER_ENABLE 0x00000310 + +#define NV10_3D_LIGHTING_ENABLE 0x00000314 + +#define NV10_3D_POINT_PARAMETERS_ENABLE 0x00000318 + +#define NV10_3D_POINT_SMOOTH_ENABLE 0x0000031c + +#define NV10_3D_LINE_SMOOTH_ENABLE 0x00000320 + +#define NV10_3D_POLYGON_SMOOTH_ENABLE 0x00000324 + +#define NV10_3D_STENCIL_ENABLE 0x0000032c + +#define NV10_3D_POLYGON_OFFSET_POINT_ENABLE 0x00000330 + +#define NV10_3D_POLYGON_OFFSET_LINE_ENABLE 0x00000334 + +#define NV10_3D_POLYGON_OFFSET_FILL_ENABLE 0x00000338 + +#define NV10_3D_ALPHA_FUNC_FUNC 0x0000033c +#define NV10_3D_ALPHA_FUNC_FUNC_NEVER 0x00000200 +#define NV10_3D_ALPHA_FUNC_FUNC_LESS 0x00000201 +#define NV10_3D_ALPHA_FUNC_FUNC_EQUAL 0x00000202 +#define NV10_3D_ALPHA_FUNC_FUNC_LEQUAL 0x00000203 +#define NV10_3D_ALPHA_FUNC_FUNC_GREATER 0x00000204 +#define NV10_3D_ALPHA_FUNC_FUNC_NOTEQUAL 0x00000205 +#define NV10_3D_ALPHA_FUNC_FUNC_GEQUAL 0x00000206 +#define NV10_3D_ALPHA_FUNC_FUNC_ALWAYS 0x00000207 + +#define NV10_3D_ALPHA_FUNC_REF 0x00000340 + +#define NV10_3D_BLEND_FUNC_SRC 0x00000344 +#define NV10_3D_BLEND_FUNC_SRC_ZERO 0x00000000 +#define NV10_3D_BLEND_FUNC_SRC_ONE 0x00000001 +#define NV10_3D_BLEND_FUNC_SRC_SRC_COLOR 0x00000300 +#define NV10_3D_BLEND_FUNC_SRC_ONE_MINUS_SRC_COLOR 0x00000301 +#define NV10_3D_BLEND_FUNC_SRC_SRC_ALPHA 0x00000302 +#define NV10_3D_BLEND_FUNC_SRC_ONE_MINUS_SRC_ALPHA 0x00000303 +#define NV10_3D_BLEND_FUNC_SRC_DST_ALPHA 0x00000304 +#define NV10_3D_BLEND_FUNC_SRC_ONE_MINUS_DST_ALPHA 0x00000305 +#define NV10_3D_BLEND_FUNC_SRC_DST_COLOR 0x00000306 +#define NV10_3D_BLEND_FUNC_SRC_ONE_MINUS_DST_COLOR 0x00000307 +#define NV10_3D_BLEND_FUNC_SRC_SRC_ALPHA_SATURATE 0x00000308 +#define NV10_3D_BLEND_FUNC_SRC_CONSTANT_COLOR 0x00008001 +#define NV10_3D_BLEND_FUNC_SRC_ONE_MINUS_CONSTANT_COLOR 0x00008002 +#define NV10_3D_BLEND_FUNC_SRC_CONSTANT_ALPHA 0x00008003 +#define NV10_3D_BLEND_FUNC_SRC_ONE_MINUS_CONSTANT_ALPHA 0x00008004 + +#define NV10_3D_BLEND_FUNC_DST 0x00000348 +#define NV10_3D_BLEND_FUNC_DST_ZERO 0x00000000 +#define NV10_3D_BLEND_FUNC_DST_ONE 0x00000001 +#define NV10_3D_BLEND_FUNC_DST_SRC_COLOR 0x00000300 +#define NV10_3D_BLEND_FUNC_DST_ONE_MINUS_SRC_COLOR 0x00000301 +#define NV10_3D_BLEND_FUNC_DST_SRC_ALPHA 0x00000302 +#define NV10_3D_BLEND_FUNC_DST_ONE_MINUS_SRC_ALPHA 0x00000303 +#define NV10_3D_BLEND_FUNC_DST_DST_ALPHA 0x00000304 +#define NV10_3D_BLEND_FUNC_DST_ONE_MINUS_DST_ALPHA 0x00000305 +#define NV10_3D_BLEND_FUNC_DST_DST_COLOR 0x00000306 +#define NV10_3D_BLEND_FUNC_DST_ONE_MINUS_DST_COLOR 0x00000307 +#define NV10_3D_BLEND_FUNC_DST_SRC_ALPHA_SATURATE 0x00000308 +#define NV10_3D_BLEND_FUNC_DST_CONSTANT_COLOR 0x00008001 +#define NV10_3D_BLEND_FUNC_DST_ONE_MINUS_CONSTANT_COLOR 0x00008002 +#define NV10_3D_BLEND_FUNC_DST_CONSTANT_ALPHA 0x00008003 +#define NV10_3D_BLEND_FUNC_DST_ONE_MINUS_CONSTANT_ALPHA 0x00008004 + +#define NV10_3D_BLEND_COLOR 0x0000034c +#define NV10_3D_BLEND_COLOR_B__MASK 0x000000ff +#define NV10_3D_BLEND_COLOR_B__SHIFT 0 +#define NV10_3D_BLEND_COLOR_G__MASK 0x0000ff00 +#define NV10_3D_BLEND_COLOR_G__SHIFT 8 +#define NV10_3D_BLEND_COLOR_R__MASK 0x00ff0000 +#define NV10_3D_BLEND_COLOR_R__SHIFT 16 +#define NV10_3D_BLEND_COLOR_A__MASK 0xff000000 +#define NV10_3D_BLEND_COLOR_A__SHIFT 24 + +#define NV10_3D_BLEND_EQUATION 0x00000350 +#define NV10_3D_BLEND_EQUATION_FUNC_ADD 0x00008006 +#define NV10_3D_BLEND_EQUATION_MIN 0x00008007 +#define NV10_3D_BLEND_EQUATION_MAX 0x00008008 +#define NV10_3D_BLEND_EQUATION_FUNC_SUBTRACT 0x0000800a +#define NV10_3D_BLEND_EQUATION_FUNC_REVERSE_SUBTRACT 0x0000800b + +#define NV10_3D_DEPTH_FUNC 0x00000354 +#define NV10_3D_DEPTH_FUNC_NEVER 0x00000200 +#define NV10_3D_DEPTH_FUNC_LESS 0x00000201 +#define NV10_3D_DEPTH_FUNC_EQUAL 0x00000202 +#define NV10_3D_DEPTH_FUNC_LEQUAL 0x00000203 +#define NV10_3D_DEPTH_FUNC_GREATER 0x00000204 +#define NV10_3D_DEPTH_FUNC_NOTEQUAL 0x00000205 +#define NV10_3D_DEPTH_FUNC_GEQUAL 0x00000206 +#define NV10_3D_DEPTH_FUNC_ALWAYS 0x00000207 + +#define NV10_3D_COLOR_MASK 0x00000358 +#define NV10_3D_COLOR_MASK_B 0x00000001 +#define NV10_3D_COLOR_MASK_G 0x00000100 +#define NV10_3D_COLOR_MASK_R 0x00010000 +#define NV10_3D_COLOR_MASK_A 0x01000000 + +#define NV10_3D_DEPTH_WRITE_ENABLE 0x0000035c + +#define NV10_3D_STENCIL_MASK 0x00000360 + +#define NV10_3D_STENCIL_FUNC_FUNC 0x00000364 +#define NV10_3D_STENCIL_FUNC_FUNC_NEVER 0x00000200 +#define NV10_3D_STENCIL_FUNC_FUNC_LESS 0x00000201 +#define NV10_3D_STENCIL_FUNC_FUNC_EQUAL 0x00000202 +#define NV10_3D_STENCIL_FUNC_FUNC_LEQUAL 0x00000203 +#define NV10_3D_STENCIL_FUNC_FUNC_GREATER 0x00000204 +#define NV10_3D_STENCIL_FUNC_FUNC_NOTEQUAL 0x00000205 +#define NV10_3D_STENCIL_FUNC_FUNC_GEQUAL 0x00000206 +#define NV10_3D_STENCIL_FUNC_FUNC_ALWAYS 0x00000207 + +#define NV10_3D_STENCIL_FUNC_REF 0x00000368 + +#define NV10_3D_STENCIL_FUNC_MASK 0x0000036c + +#define NV10_3D_STENCIL_OP_FAIL 0x00000370 +#define NV10_3D_STENCIL_OP_FAIL_ZERO 0x00000000 +#define NV10_3D_STENCIL_OP_FAIL_INVERT 0x0000150a +#define NV10_3D_STENCIL_OP_FAIL_KEEP 0x00001e00 +#define NV10_3D_STENCIL_OP_FAIL_REPLACE 0x00001e01 +#define NV10_3D_STENCIL_OP_FAIL_INCR 0x00001e02 +#define NV10_3D_STENCIL_OP_FAIL_DECR 0x00001e03 +#define NV10_3D_STENCIL_OP_FAIL_INCR_WRAP 0x00008507 +#define NV10_3D_STENCIL_OP_FAIL_DECR_WRAP 0x00008508 + +#define NV10_3D_STENCIL_OP_ZFAIL 0x00000374 +#define NV10_3D_STENCIL_OP_ZFAIL_ZERO 0x00000000 +#define NV10_3D_STENCIL_OP_ZFAIL_INVERT 0x0000150a +#define NV10_3D_STENCIL_OP_ZFAIL_KEEP 0x00001e00 +#define NV10_3D_STENCIL_OP_ZFAIL_REPLACE 0x00001e01 +#define NV10_3D_STENCIL_OP_ZFAIL_INCR 0x00001e02 +#define NV10_3D_STENCIL_OP_ZFAIL_DECR 0x00001e03 +#define NV10_3D_STENCIL_OP_ZFAIL_INCR_WRAP 0x00008507 +#define NV10_3D_STENCIL_OP_ZFAIL_DECR_WRAP 0x00008508 + +#define NV10_3D_STENCIL_OP_ZPASS 0x00000378 +#define NV10_3D_STENCIL_OP_ZPASS_ZERO 0x00000000 +#define NV10_3D_STENCIL_OP_ZPASS_INVERT 0x0000150a +#define NV10_3D_STENCIL_OP_ZPASS_KEEP 0x00001e00 +#define NV10_3D_STENCIL_OP_ZPASS_REPLACE 0x00001e01 +#define NV10_3D_STENCIL_OP_ZPASS_INCR 0x00001e02 +#define NV10_3D_STENCIL_OP_ZPASS_DECR 0x00001e03 +#define NV10_3D_STENCIL_OP_ZPASS_INCR_WRAP 0x00008507 +#define NV10_3D_STENCIL_OP_ZPASS_DECR_WRAP 0x00008508 + +#define NV10_3D_SHADE_MODEL 0x0000037c +#define NV10_3D_SHADE_MODEL_FLAT 0x00001d00 +#define NV10_3D_SHADE_MODEL_SMOOTH 0x00001d01 + +#define NV10_3D_LINE_WIDTH 0x00000380 + +#define NV10_3D_POLYGON_OFFSET_FACTOR 0x00000384 + +#define NV10_3D_POLYGON_OFFSET_UNITS 0x00000388 + +#define NV10_3D_POLYGON_MODE_FRONT 0x0000038c +#define NV10_3D_POLYGON_MODE_FRONT_POINT 0x00001b00 +#define NV10_3D_POLYGON_MODE_FRONT_LINE 0x00001b01 +#define NV10_3D_POLYGON_MODE_FRONT_FILL 0x00001b02 + +#define NV10_3D_POLYGON_MODE_BACK 0x00000390 +#define NV10_3D_POLYGON_MODE_BACK_POINT 0x00001b00 +#define NV10_3D_POLYGON_MODE_BACK_LINE 0x00001b01 +#define NV10_3D_POLYGON_MODE_BACK_FILL 0x00001b02 + +#define NV10_3D_DEPTH_RANGE_NEAR 0x00000394 + +#define NV10_3D_DEPTH_RANGE_FAR 0x00000398 + +#define NV10_3D_CULL_FACE 0x0000039c +#define NV10_3D_CULL_FACE_FRONT 0x00000404 +#define NV10_3D_CULL_FACE_BACK 0x00000405 +#define NV10_3D_CULL_FACE_FRONT_AND_BACK 0x00000408 + +#define NV10_3D_FRONT_FACE 0x000003a0 +#define NV10_3D_FRONT_FACE_CW 0x00000900 +#define NV10_3D_FRONT_FACE_CCW 0x00000901 + + +#define NV10_3D_VERTEX_POS_3F 0x00000c00 + + +#define NV10_3D_VERTEX_POS_3F_X 0x00000c00 + +#define NV10_3D_VERTEX_POS_3F_Y 0x00000c04 + +#define NV10_3D_VERTEX_POS_3F_Z 0x00000c08 + +#define NV10_3D_VERTEX_POS_4F 0x00000c18 + + +#define NV10_3D_VERTEX_POS_4F_X 0x00000c18 + +#define NV10_3D_VERTEX_POS_4F_Y 0x00000c1c + +#define NV10_3D_VERTEX_POS_4F_Z 0x00000c20 + +#define NV10_3D_VERTEX_POS_4F_W 0x00000c24 + +#define NV10_3D_VERTEX_NOR_3F 0x00000c30 + + +#define NV10_3D_VERTEX_NOR_3F_X 0x00000c30 + +#define NV10_3D_VERTEX_NOR_3F_Y 0x00000c34 + +#define NV10_3D_VERTEX_NOR_3F_Z 0x00000c38 + +#define NV10_3D_VERTEX_NOR_3I 0x00000c30 + + +#define NV10_3D_VERTEX_NOR_3I_XY 0x00000c30 +#define NV10_3D_VERTEX_NOR_3I_XY_X__MASK 0x0000ffff +#define NV10_3D_VERTEX_NOR_3I_XY_X__SHIFT 0 +#define NV10_3D_VERTEX_NOR_3I_XY_Y__MASK 0xffff0000 +#define NV10_3D_VERTEX_NOR_3I_XY_Y__SHIFT 16 + +#define NV10_3D_VERTEX_NOR_3I_Z 0x00000c34 +#define NV10_3D_VERTEX_NOR_3I_Z_Z__MASK 0x0000ffff +#define NV10_3D_VERTEX_NOR_3I_Z_Z__SHIFT 0 + +#define NV10_3D_VERTEX_COL_4F 0x00000c50 + + +#define NV10_3D_VERTEX_COL_4F_R 0x00000c50 + +#define NV10_3D_VERTEX_COL_4F_G 0x00000c54 + +#define NV10_3D_VERTEX_COL_4F_B 0x00000c58 + +#define NV10_3D_VERTEX_COL_4F_A 0x00000c5c + +#define NV10_3D_VERTEX_COL_3F 0x00000c60 + + +#define NV10_3D_VERTEX_COL_3F_R 0x00000c60 + +#define NV10_3D_VERTEX_COL_3F_G 0x00000c64 + +#define NV10_3D_VERTEX_COL_3F_B 0x00000c68 + +#define NV10_3D_VERTEX_COL_4I 0x00000c6c +#define NV10_3D_VERTEX_COL_4I_R__MASK 0x000000ff +#define NV10_3D_VERTEX_COL_4I_R__SHIFT 0 +#define NV10_3D_VERTEX_COL_4I_G__MASK 0x0000ff00 +#define NV10_3D_VERTEX_COL_4I_G__SHIFT 8 +#define NV10_3D_VERTEX_COL_4I_B__MASK 0x00ff0000 +#define NV10_3D_VERTEX_COL_4I_B__SHIFT 16 +#define NV10_3D_VERTEX_COL_4I_A__MASK 0xff000000 +#define NV10_3D_VERTEX_COL_4I_A__SHIFT 24 + +#define NV10_3D_VERTEX_COL2_3F 0x00000c80 + + +#define NV10_3D_VERTEX_COL2_3F_R 0x00000c80 + +#define NV10_3D_VERTEX_COL2_3F_G 0x00000c84 + +#define NV10_3D_VERTEX_COL2_3F_B 0x00000c88 + +#define NV10_3D_VERTEX_COL2_3I 0x00000c8c +#define NV10_3D_VERTEX_COL2_3I_R__MASK 0x000000ff +#define NV10_3D_VERTEX_COL2_3I_R__SHIFT 0 +#define NV10_3D_VERTEX_COL2_3I_G__MASK 0x0000ff00 +#define NV10_3D_VERTEX_COL2_3I_G__SHIFT 8 +#define NV10_3D_VERTEX_COL2_3I_B__MASK 0x00ff0000 +#define NV10_3D_VERTEX_COL2_3I_B__SHIFT 16 + +#define NV10_3D_VERTEX_TX0_2F 0x00000c90 + + +#define NV10_3D_VERTEX_TX0_2F_S 0x00000c90 + +#define NV10_3D_VERTEX_TX0_2F_T 0x00000c94 + +#define NV10_3D_VERTEX_TX0_2I 0x00000c98 +#define NV10_3D_VERTEX_TX0_2I_S__MASK 0x0000ffff +#define NV10_3D_VERTEX_TX0_2I_S__SHIFT 0 +#define NV10_3D_VERTEX_TX0_2I_T__MASK 0xffff0000 +#define NV10_3D_VERTEX_TX0_2I_T__SHIFT 16 + +#define NV10_3D_VERTEX_TX0_4F 0x00000ca0 + + +#define NV10_3D_VERTEX_TX0_4F_S 0x00000ca0 + +#define NV10_3D_VERTEX_TX0_4F_T 0x00000ca4 + +#define NV10_3D_VERTEX_TX0_4F_R 0x00000ca8 + +#define NV10_3D_VERTEX_TX0_4F_Q 0x00000cac + +#define NV10_3D_VERTEX_TX0_4I 0x00000cb0 + + +#define NV10_3D_VERTEX_TX0_4I_ST 0x00000cb0 +#define NV10_3D_VERTEX_TX0_4I_ST_S__MASK 0x0000ffff +#define NV10_3D_VERTEX_TX0_4I_ST_S__SHIFT 0 +#define NV10_3D_VERTEX_TX0_4I_ST_T__MASK 0xffff0000 +#define NV10_3D_VERTEX_TX0_4I_ST_T__SHIFT 16 + +#define NV10_3D_VERTEX_TX0_4I_RQ 0x00000cb4 +#define NV10_3D_VERTEX_TX0_4I_RQ_R__MASK 0x0000ffff +#define NV10_3D_VERTEX_TX0_4I_RQ_R__SHIFT 0 +#define NV10_3D_VERTEX_TX0_4I_RQ_Q__MASK 0xffff0000 +#define NV10_3D_VERTEX_TX0_4I_RQ_Q__SHIFT 16 + +#define NV10_3D_VERTEX_TX1_2F 0x00000cb8 + + +#define NV10_3D_VERTEX_TX1_2F_S 0x00000cb8 + +#define NV10_3D_VERTEX_TX1_2F_T 0x00000cbc + +#define NV10_3D_VERTEX_TX1_2I 0x00000cc0 +#define NV10_3D_VERTEX_TX1_2I_S__MASK 0x0000ffff +#define NV10_3D_VERTEX_TX1_2I_S__SHIFT 0 +#define NV10_3D_VERTEX_TX1_2I_T__MASK 0xffff0000 +#define NV10_3D_VERTEX_TX1_2I_T__SHIFT 16 + +#define NV10_3D_VERTEX_TX1_4F 0x00000cc8 + + +#define NV10_3D_VERTEX_TX1_4F_S 0x00000cc8 + +#define NV10_3D_VERTEX_TX1_4F_T 0x00000ccc + +#define NV10_3D_VERTEX_TX1_4F_R 0x00000cd0 + +#define NV10_3D_VERTEX_TX1_4F_Q 0x00000cd4 + +#define NV10_3D_VERTEX_TX1_4I 0x00000cd8 + + +#define NV10_3D_VERTEX_TX1_4I_ST 0x00000cd8 +#define NV10_3D_VERTEX_TX1_4I_ST_S__MASK 0x0000ffff +#define NV10_3D_VERTEX_TX1_4I_ST_S__SHIFT 0 +#define NV10_3D_VERTEX_TX1_4I_ST_T__MASK 0xffff0000 +#define NV10_3D_VERTEX_TX1_4I_ST_T__SHIFT 16 + +#define NV10_3D_VERTEX_TX1_4I_RQ 0x00000cdc +#define NV10_3D_VERTEX_TX1_4I_RQ_R__MASK 0x0000ffff +#define NV10_3D_VERTEX_TX1_4I_RQ_R__SHIFT 0 +#define NV10_3D_VERTEX_TX1_4I_RQ_Q__MASK 0xffff0000 +#define NV10_3D_VERTEX_TX1_4I_RQ_Q__SHIFT 16 + +#define NV10_3D_VERTEX_FOG_1F 0x00000ce0 + +#define NV10_3D_VERTEX_WGH_1F 0x00000ce4 + +#define NV10_3D_EDGEFLAG_ENABLE 0x00000cec + + +#define NV10_3D_DMA_VTXBUF 0x0000018c + +#define NV10_3D_VTXBUF_VALIDATE 0x00000cf0 + + +#define NV10_3D_VTXBUF_OFFSET(i0) (0x00000d00 + 0x8*(i0)) + +#define NV10_3D_VTXBUF_FMT(i0) (0x00000d04 + 0x8*(i0)) +#define NV10_3D_VTXBUF_FMT_TYPE__MASK 0x0000000f +#define NV10_3D_VTXBUF_FMT_TYPE__SHIFT 0 +#define NV10_3D_VTXBUF_FMT_TYPE_B8G8R8A8_UNORM 0x00000000 +#define NV10_3D_VTXBUF_FMT_TYPE_V16_SNORM 0x00000001 +#define NV10_3D_VTXBUF_FMT_TYPE_V32_FLOAT 0x00000002 +#define NV10_3D_VTXBUF_FMT_TYPE_U8_UNORM 0x00000004 +#define NV10_3D_VTXBUF_FMT_FIELDS__MASK 0x000000f0 +#define NV10_3D_VTXBUF_FMT_FIELDS__SHIFT 4 +#define NV10_3D_VTXBUF_FMT_STRIDE__MASK 0x0000ff00 +#define NV10_3D_VTXBUF_FMT_STRIDE__SHIFT 8 +#define NV10_3D_VTXBUF_FMT_HOMOGENEOUS 0x01000000 + +#define NV10_3D_VERTEX_BEGIN_END 0x00000dfc +#define NV10_3D_VERTEX_BEGIN_END_STOP 0x00000000 +#define NV10_3D_VERTEX_BEGIN_END_POINTS 0x00000001 +#define NV10_3D_VERTEX_BEGIN_END_LINES 0x00000002 +#define NV10_3D_VERTEX_BEGIN_END_LINE_LOOP 0x00000003 +#define NV10_3D_VERTEX_BEGIN_END_LINE_STRIP 0x00000004 +#define NV10_3D_VERTEX_BEGIN_END_TRIANGLES 0x00000005 +#define NV10_3D_VERTEX_BEGIN_END_TRIANGLE_STRIP 0x00000006 +#define NV10_3D_VERTEX_BEGIN_END_TRIANGLE_FAN 0x00000007 +#define NV10_3D_VERTEX_BEGIN_END_QUADS 0x00000008 +#define NV10_3D_VERTEX_BEGIN_END_QUAD_STRIP 0x00000009 +#define NV10_3D_VERTEX_BEGIN_END_POLYGON 0x0000000a + +#define NV10_3D_VTXBUF_ELEMENT_U16 0x00000e00 +#define NV10_3D_VTXBUF_ELEMENT_U16_I0__MASK 0x0000ffff +#define NV10_3D_VTXBUF_ELEMENT_U16_I0__SHIFT 0 +#define NV10_3D_VTXBUF_ELEMENT_U16_I1__MASK 0xffff0000 +#define NV10_3D_VTXBUF_ELEMENT_U16_I1__SHIFT 16 + +#define NV10_3D_VTXBUF_ELEMENT_U32 0x00001100 + +#define NV10_3D_VTXBUF_BEGIN_END 0x000013fc +#define NV10_3D_VTXBUF_BEGIN_END_STOP 0x00000000 +#define NV10_3D_VTXBUF_BEGIN_END_POINTS 0x00000001 +#define NV10_3D_VTXBUF_BEGIN_END_LINES 0x00000002 +#define NV10_3D_VTXBUF_BEGIN_END_LINE_LOOP 0x00000003 +#define NV10_3D_VTXBUF_BEGIN_END_LINE_STRIP 0x00000004 +#define NV10_3D_VTXBUF_BEGIN_END_TRIANGLES 0x00000005 +#define NV10_3D_VTXBUF_BEGIN_END_TRIANGLE_STRIP 0x00000006 +#define NV10_3D_VTXBUF_BEGIN_END_TRIANGLE_FAN 0x00000007 +#define NV10_3D_VTXBUF_BEGIN_END_QUADS 0x00000008 +#define NV10_3D_VTXBUF_BEGIN_END_QUAD_STRIP 0x00000009 +#define NV10_3D_VTXBUF_BEGIN_END_POLYGON 0x0000000a + +#define NV10_3D_VTXBUF_BATCH 0x00001400 +#define NV10_3D_VTXBUF_BATCH_FIRST__MASK 0x0000ffff +#define NV10_3D_VTXBUF_BATCH_FIRST__SHIFT 0 +#define NV10_3D_VTXBUF_BATCH_LAST__MASK 0xff000000 +#define NV10_3D_VTXBUF_BATCH_LAST__SHIFT 24 + +#define NV10_3D_VTXBUF_DATA 0x00001800 + + +#define NV10_3D_VERTEX_WEIGHT_ENABLE 0x00000328 + +#define NV10_3D_VIEW_MATRIX_ENABLE 0x000003e8 +#define NV10_3D_VIEW_MATRIX_ENABLE_MODELVIEW1 0x00000001 +#define NV10_3D_VIEW_MATRIX_ENABLE_MODELVIEW0 0x00000002 +#define NV10_3D_VIEW_MATRIX_ENABLE_PROJECTION 0x00000004 + + +#define NV10_3D_MODELVIEW_MATRIX(i0, i1) (0x00000400 + 0x40*(i0) + 0x4*(i1)) +#define NV10_3D_MODELVIEW_MATRIX__ESIZE 0x00000004 +#define NV10_3D_MODELVIEW_MATRIX__LEN 0x00000010 + +#define NV10_3D_INVERSE_MODELVIEW_MATRIX(i0, i1) (0x00000480 + 0x40*(i0) + 0x4*(i1)) +#define NV10_3D_INVERSE_MODELVIEW_MATRIX__ESIZE 0x00000004 +#define NV10_3D_INVERSE_MODELVIEW_MATRIX__LEN 0x0000000c + +#define NV10_3D_PROJECTION_MATRIX(i0) (0x00000500 + 0x4*(i0)) +#define NV10_3D_PROJECTION_MATRIX__ESIZE 0x00000004 +#define NV10_3D_PROJECTION_MATRIX__LEN 0x00000010 + +#define NV10_3D_VIEWPORT_TRANSLATE 0x000006e8 + + +#define NV10_3D_VIEWPORT_TRANSLATE_X 0x000006e8 + +#define NV10_3D_VIEWPORT_TRANSLATE_Y 0x000006ec + +#define NV10_3D_VIEWPORT_TRANSLATE_Z 0x000006f0 + +#define NV10_3D_VIEWPORT_TRANSLATE_W 0x000006f4 + + +#define NV10_3D_LIGHT_MODEL 0x00000294 +#define NV10_3D_LIGHT_MODEL_VERTEX_SPECULAR 0x00000001 +#define NV10_3D_LIGHT_MODEL_SEPARATE_SPECULAR 0x00000002 +#define NV10_3D_LIGHT_MODEL_LOCAL_VIEWER 0x00010000 + +#define NV10_3D_COLOR_MATERIAL 0x00000298 +#define NV10_3D_COLOR_MATERIAL_EMISSION 0x00000001 +#define NV10_3D_COLOR_MATERIAL_AMBIENT 0x00000002 +#define NV10_3D_COLOR_MATERIAL_DIFFUSE 0x00000004 +#define NV10_3D_COLOR_MATERIAL_SPECULAR 0x00000008 + +#define NV10_3D_MATERIAL_FACTOR 0x000003a8 + + +#define NV10_3D_MATERIAL_FACTOR_R 0x000003a8 + +#define NV10_3D_MATERIAL_FACTOR_G 0x000003ac + +#define NV10_3D_MATERIAL_FACTOR_B 0x000003b0 + +#define NV10_3D_MATERIAL_FACTOR_A 0x000003b4 + +#define NV10_3D_NORMALIZE_ENABLE 0x000003a4 + +#define NV10_3D_SEPARATE_SPECULAR_ENABLE 0x000003b8 + +#define NV10_3D_ENABLED_LIGHTS 0x000003bc +#define NV10_3D_ENABLED_LIGHTS_0__MASK 0x00000003 +#define NV10_3D_ENABLED_LIGHTS_0__SHIFT 0 +#define NV10_3D_ENABLED_LIGHTS_0_DISABLED 0x00000000 +#define NV10_3D_ENABLED_LIGHTS_0_NONPOSITIONAL 0x00000001 +#define NV10_3D_ENABLED_LIGHTS_0_POSITIONAL 0x00000002 +#define NV10_3D_ENABLED_LIGHTS_0_DIRECTIONAL 0x00000003 +#define NV10_3D_ENABLED_LIGHTS_1__MASK 0x0000000c +#define NV10_3D_ENABLED_LIGHTS_1__SHIFT 2 +#define NV10_3D_ENABLED_LIGHTS_1_DISABLED 0x00000000 +#define NV10_3D_ENABLED_LIGHTS_1_NONPOSITIONAL 0x00000004 +#define NV10_3D_ENABLED_LIGHTS_1_POSITIONAL 0x00000008 +#define NV10_3D_ENABLED_LIGHTS_1_DIRECTIONAL 0x0000000c +#define NV10_3D_ENABLED_LIGHTS_2__MASK 0x00000030 +#define NV10_3D_ENABLED_LIGHTS_2__SHIFT 4 +#define NV10_3D_ENABLED_LIGHTS_2_DISABLED 0x00000000 +#define NV10_3D_ENABLED_LIGHTS_2_NONPOSITIONAL 0x00000010 +#define NV10_3D_ENABLED_LIGHTS_2_POSITIONAL 0x00000020 +#define NV10_3D_ENABLED_LIGHTS_2_DIRECTIONAL 0x00000030 +#define NV10_3D_ENABLED_LIGHTS_3__MASK 0x000000c0 +#define NV10_3D_ENABLED_LIGHTS_3__SHIFT 6 +#define NV10_3D_ENABLED_LIGHTS_3_DISABLED 0x00000000 +#define NV10_3D_ENABLED_LIGHTS_3_NONPOSITIONAL 0x00000040 +#define NV10_3D_ENABLED_LIGHTS_3_POSITIONAL 0x00000080 +#define NV10_3D_ENABLED_LIGHTS_3_DIRECTIONAL 0x000000c0 +#define NV10_3D_ENABLED_LIGHTS_4__MASK 0x00000300 +#define NV10_3D_ENABLED_LIGHTS_4__SHIFT 8 +#define NV10_3D_ENABLED_LIGHTS_4_DISABLED 0x00000000 +#define NV10_3D_ENABLED_LIGHTS_4_NONPOSITIONAL 0x00000100 +#define NV10_3D_ENABLED_LIGHTS_4_POSITIONAL 0x00000200 +#define NV10_3D_ENABLED_LIGHTS_4_DIRECTIONAL 0x00000300 +#define NV10_3D_ENABLED_LIGHTS_5__MASK 0x00000c00 +#define NV10_3D_ENABLED_LIGHTS_5__SHIFT 10 +#define NV10_3D_ENABLED_LIGHTS_5_DISABLED 0x00000000 +#define NV10_3D_ENABLED_LIGHTS_5_NONPOSITIONAL 0x00000400 +#define NV10_3D_ENABLED_LIGHTS_5_POSITIONAL 0x00000800 +#define NV10_3D_ENABLED_LIGHTS_5_DIRECTIONAL 0x00000c00 +#define NV10_3D_ENABLED_LIGHTS_6__MASK 0x00003000 +#define NV10_3D_ENABLED_LIGHTS_6__SHIFT 12 +#define NV10_3D_ENABLED_LIGHTS_6_DISABLED 0x00000000 +#define NV10_3D_ENABLED_LIGHTS_6_NONPOSITIONAL 0x00001000 +#define NV10_3D_ENABLED_LIGHTS_6_POSITIONAL 0x00002000 +#define NV10_3D_ENABLED_LIGHTS_6_DIRECTIONAL 0x00003000 +#define NV10_3D_ENABLED_LIGHTS_7__MASK 0x0000c000 +#define NV10_3D_ENABLED_LIGHTS_7__SHIFT 14 +#define NV10_3D_ENABLED_LIGHTS_7_DISABLED 0x00000000 +#define NV10_3D_ENABLED_LIGHTS_7_NONPOSITIONAL 0x00004000 +#define NV10_3D_ENABLED_LIGHTS_7_POSITIONAL 0x00008000 +#define NV10_3D_ENABLED_LIGHTS_7_DIRECTIONAL 0x0000c000 + +#define NV10_3D_MATERIAL_SHININESS(i0) (0x000006a0 + 0x4*(i0)) +#define NV10_3D_MATERIAL_SHININESS__ESIZE 0x00000004 +#define NV10_3D_MATERIAL_SHININESS__LEN 0x00000006 + +#define NV10_3D_LIGHT_MODEL_AMBIENT 0x000006c4 + + +#define NV10_3D_LIGHT_MODEL_AMBIENT_R 0x000006c4 + +#define NV10_3D_LIGHT_MODEL_AMBIENT_G 0x000006c8 + +#define NV10_3D_LIGHT_MODEL_AMBIENT_B 0x000006cc + +#define NV10_3D_LIGHT(i0) (0x00000800 + 0x80*(i0)) +#define NV10_3D_LIGHT__ESIZE 0x00000080 +#define NV10_3D_LIGHT__LEN 0x00000008 + +#define NV10_3D_LIGHT_AMBIENT(i0) (0x00000800 + 0x80*(i0)) + + +#define NV10_3D_LIGHT_AMBIENT_R(i0) (0x00000800 + 0x80*(i0)) + +#define NV10_3D_LIGHT_AMBIENT_G(i0) (0x00000804 + 0x80*(i0)) + +#define NV10_3D_LIGHT_AMBIENT_B(i0) (0x00000808 + 0x80*(i0)) + +#define NV10_3D_LIGHT_DIFFUSE(i0) (0x0000080c + 0x80*(i0)) + + +#define NV10_3D_LIGHT_DIFFUSE_R(i0) (0x0000080c + 0x80*(i0)) + +#define NV10_3D_LIGHT_DIFFUSE_G(i0) (0x00000810 + 0x80*(i0)) + +#define NV10_3D_LIGHT_DIFFUSE_B(i0) (0x00000814 + 0x80*(i0)) + +#define NV10_3D_LIGHT_SPECULAR(i0) (0x00000818 + 0x80*(i0)) + + +#define NV10_3D_LIGHT_SPECULAR_R(i0) (0x00000818 + 0x80*(i0)) + +#define NV10_3D_LIGHT_SPECULAR_G(i0) (0x0000081c + 0x80*(i0)) + +#define NV10_3D_LIGHT_SPECULAR_B(i0) (0x00000820 + 0x80*(i0)) + +#define NV10_3D_LIGHT_HALF_VECTOR(i0) (0x00000828 + 0x80*(i0)) + + +#define NV10_3D_LIGHT_HALF_VECTOR_X(i0) (0x00000828 + 0x80*(i0)) + +#define NV10_3D_LIGHT_HALF_VECTOR_Y(i0) (0x0000082c + 0x80*(i0)) + +#define NV10_3D_LIGHT_HALF_VECTOR_Z(i0) (0x00000830 + 0x80*(i0)) + +#define NV10_3D_LIGHT_DIRECTION(i0) (0x00000834 + 0x80*(i0)) + + +#define NV10_3D_LIGHT_DIRECTION_X(i0) (0x00000834 + 0x80*(i0)) + +#define NV10_3D_LIGHT_DIRECTION_Y(i0) (0x00000838 + 0x80*(i0)) + +#define NV10_3D_LIGHT_DIRECTION_Z(i0) (0x0000083c + 0x80*(i0)) + +#define NV10_3D_LIGHT_SPOT_CUTOFF(i0, i1) (0x00000840 + 0x80*(i0) + 0x4*(i1)) +#define NV10_3D_LIGHT_SPOT_CUTOFF__ESIZE 0x00000004 +#define NV10_3D_LIGHT_SPOT_CUTOFF__LEN 0x00000007 + +#define NV10_3D_LIGHT_POSITION(i0) (0x0000085c + 0x80*(i0)) + + +#define NV10_3D_LIGHT_POSITION_X(i0) (0x0000085c + 0x80*(i0)) + +#define NV10_3D_LIGHT_POSITION_Y(i0) (0x00000860 + 0x80*(i0)) + +#define NV10_3D_LIGHT_POSITION_Z(i0) (0x00000864 + 0x80*(i0)) + +#define NV10_3D_LIGHT_ATTENUATION(i0) (0x00000868 + 0x80*(i0)) + +#define NV10_3D_LIGHT_ATTENUATION_CONSTANT(i0) (0x00000868 + 0x80*(i0)) + +#define NV10_3D_LIGHT_ATTENUATION_LINEAR(i0) (0x0000086c + 0x80*(i0)) + +#define NV10_3D_LIGHT_ATTENUATION_QUADRATIC(i0) (0x00000870 + 0x80*(i0)) + + +#define NV10_3D_FOG_MODE 0x0000029c +#define NV10_3D_FOG_MODE_LINEAR 0x00002601 +#define NV10_3D_FOG_MODE_EXP 0x00000800 +#define NV10_3D_FOG_MODE_EXP_ABS 0x00000802 +#define NV10_3D_FOG_MODE_EXP2 0x00000803 + +#define NV10_3D_FOG_COORD 0x000002a0 +#define NV10_3D_FOG_COORD_FOG 0x00000000 +#define NV10_3D_FOG_COORD_DIST_RADIAL 0x00000001 +#define NV10_3D_FOG_COORD_DIST_ORTHOGONAL 0x00000002 +#define NV10_3D_FOG_COORD_DIST_ORTHOGONAL_ABS 0x00000003 + +#define NV10_3D_FOG_ENABLE 0x000002a4 + +#define NV10_3D_FOG_COLOR 0x000002a8 +#define NV10_3D_FOG_COLOR_R__MASK 0x000000ff +#define NV10_3D_FOG_COLOR_R__SHIFT 0 +#define NV10_3D_FOG_COLOR_G__MASK 0x0000ff00 +#define NV10_3D_FOG_COLOR_G__SHIFT 8 +#define NV10_3D_FOG_COLOR_B__MASK 0x00ff0000 +#define NV10_3D_FOG_COLOR_B__SHIFT 16 +#define NV10_3D_FOG_COLOR_A__MASK 0xff000000 +#define NV10_3D_FOG_COLOR_A__SHIFT 24 + +#define NV10_3D_FOG_COEFF(i0) (0x00000680 + 0x4*(i0)) +#define NV10_3D_FOG_COEFF__ESIZE 0x00000004 +#define NV10_3D_FOG_COEFF__LEN 0x00000003 + + + +#define NV10_3D_TEX_GEN_MODE(i0, i1) (0x000003c0 + 0x10*(i0) + 0x4*(i1)) +#define NV10_3D_TEX_GEN_MODE__ESIZE 0x00000004 +#define NV10_3D_TEX_GEN_MODE__LEN 0x00000004 +#define NV10_3D_TEX_GEN_MODE_FALSE 0x00000000 +#define NV10_3D_TEX_GEN_MODE_EYE_LINEAR 0x00002400 +#define NV10_3D_TEX_GEN_MODE_OBJECT_LINEAR 0x00002401 +#define NV10_3D_TEX_GEN_MODE_SPHERE_MAP 0x00002402 +#define NV10_3D_TEX_GEN_MODE_NORMAL_MAP 0x00008511 +#define NV10_3D_TEX_GEN_MODE_REFLECTION_MAP 0x00008512 + + +#define NV10_3D_TEX_GEN_COEFF(i0, i1) (0x00000600 + 0x40*(i0) + 0x10*(i1)) +#define NV10_3D_TEX_GEN_COEFF__ESIZE 0x00000010 +#define NV10_3D_TEX_GEN_COEFF__LEN 0x00000004 + +#define NV10_3D_TEX_GEN_COEFF_A(i0, i1) (0x00000600 + 0x40*(i0) + 0x10*(i1)) + +#define NV10_3D_TEX_GEN_COEFF_B(i0, i1) (0x00000604 + 0x40*(i0) + 0x10*(i1)) + +#define NV10_3D_TEX_GEN_COEFF_C(i0, i1) (0x00000608 + 0x40*(i0) + 0x10*(i1)) + +#define NV10_3D_TEX_GEN_COEFF_D(i0, i1) (0x0000060c + 0x40*(i0) + 0x10*(i1)) + +#define NV10_3D_TEX_MATRIX_ENABLE(i0) (0x000003e0 + 0x4*(i0)) +#define NV10_3D_TEX_MATRIX_ENABLE__ESIZE 0x00000004 +#define NV10_3D_TEX_MATRIX_ENABLE__LEN 0x00000002 + + +#define NV10_3D_TEX_MATRIX(i0, i1) (0x00000540 + 0x40*(i0) + 0x4*(i1)) +#define NV10_3D_TEX_MATRIX__ESIZE 0x00000004 +#define NV10_3D_TEX_MATRIX__LEN 0x00000010 + +#define NV10_3D_TEX(i0) (0x00000000 + 0x4*(i0)) +#define NV10_3D_TEX__ESIZE 0x00000004 +#define NV10_3D_TEX__LEN 0x00000002 + +#define NV10_3D_TEX_OFFSET(i0) (0x00000218 + 0x4*(i0)) + +#define NV10_3D_TEX_FORMAT(i0) (0x00000220 + 0x4*(i0)) +#define NV10_3D_TEX_FORMAT_DMA0 0x00000001 +#define NV10_3D_TEX_FORMAT_DMA1 0x00000002 +#define NV10_3D_TEX_FORMAT_CUBE_MAP 0x00000004 +#define NV10_3D_TEX_FORMAT_FORMAT__MASK 0x00000f80 +#define NV10_3D_TEX_FORMAT_FORMAT__SHIFT 7 +#define NV10_3D_TEX_FORMAT_FORMAT_L8 0x00000000 +#define NV10_3D_TEX_FORMAT_FORMAT_I8 0x00000080 +#define NV10_3D_TEX_FORMAT_FORMAT_A1R5G5B5 0x00000100 +#define NV10_3D_TEX_FORMAT_FORMAT_A4R4G4B4 0x00000200 +#define NV10_3D_TEX_FORMAT_FORMAT_R5G6B5 0x00000280 +#define NV10_3D_TEX_FORMAT_FORMAT_A8R8G8B8 0x00000300 +#define NV10_3D_TEX_FORMAT_FORMAT_X8R8G8B8 0x00000380 +#define NV10_3D_TEX_FORMAT_FORMAT_INDEX8 0x00000580 +#define NV10_3D_TEX_FORMAT_FORMAT_DXT1 0x00000600 +#define NV10_3D_TEX_FORMAT_FORMAT_DXT3 0x00000700 +#define NV10_3D_TEX_FORMAT_FORMAT_DXT5 0x00000780 +#define NV10_3D_TEX_FORMAT_FORMAT_A1R5G5B5_RECT 0x00000800 +#define NV10_3D_TEX_FORMAT_FORMAT_R5G6B5_RECT 0x00000880 +#define NV10_3D_TEX_FORMAT_FORMAT_A8R8G8B8_RECT 0x00000900 +#define NV10_3D_TEX_FORMAT_FORMAT_I8_RECT 0x00000980 +#define NV10_3D_TEX_FORMAT_MIPMAP 0x00008000 +#define NV10_3D_TEX_FORMAT_BASE_SIZE_U__MASK 0x000f0000 +#define NV10_3D_TEX_FORMAT_BASE_SIZE_U__SHIFT 16 +#define NV10_3D_TEX_FORMAT_BASE_SIZE_V__MASK 0x00f00000 +#define NV10_3D_TEX_FORMAT_BASE_SIZE_V__SHIFT 20 +#define NV10_3D_TEX_FORMAT_WRAP_S__MASK 0x0f000000 +#define NV10_3D_TEX_FORMAT_WRAP_S__SHIFT 24 +#define NV10_3D_TEX_FORMAT_WRAP_S_REPEAT 0x01000000 +#define NV10_3D_TEX_FORMAT_WRAP_S_MIRRORED_REPEAT 0x02000000 +#define NV10_3D_TEX_FORMAT_WRAP_S_CLAMP_TO_EDGE 0x03000000 +#define NV10_3D_TEX_FORMAT_WRAP_S_CLAMP_TO_BORDER 0x04000000 +#define NV10_3D_TEX_FORMAT_WRAP_S_CLAMP 0x05000000 +#define NV10_3D_TEX_FORMAT_WRAP_T__MASK 0xf0000000 +#define NV10_3D_TEX_FORMAT_WRAP_T__SHIFT 28 +#define NV10_3D_TEX_FORMAT_WRAP_T_REPEAT 0x10000000 +#define NV10_3D_TEX_FORMAT_WRAP_T_MIRRORED_REPEAT 0x20000000 +#define NV10_3D_TEX_FORMAT_WRAP_T_CLAMP_TO_EDGE 0x30000000 +#define NV10_3D_TEX_FORMAT_WRAP_T_CLAMP_TO_BORDER 0x40000000 +#define NV10_3D_TEX_FORMAT_WRAP_T_CLAMP 0x50000000 + +#define NV10_3D_TEX_ENABLE(i0) (0x00000228 + 0x4*(i0)) +#define NV10_3D_TEX_ENABLE_CULL__MASK 0x0000000f +#define NV10_3D_TEX_ENABLE_CULL__SHIFT 0 +#define NV10_3D_TEX_ENABLE_CULL_DISABLED 0x00000000 +#define NV10_3D_TEX_ENABLE_CULL_TEST_ALL 0x00000003 +#define NV10_3D_TEX_ENABLE_CULL_TEST_ALPHA 0x00000004 +#define NV10_3D_TEX_ENABLE_ANISOTROPY__MASK 0x00000030 +#define NV10_3D_TEX_ENABLE_ANISOTROPY__SHIFT 4 +#define NV10_3D_TEX_ENABLE_MIPMAP_MAX_LOD__MASK 0x0003c000 +#define NV10_3D_TEX_ENABLE_MIPMAP_MAX_LOD__SHIFT 14 +#define NV10_3D_TEX_ENABLE_MIPMAP_MIN_LOD__MASK 0x3c000000 +#define NV10_3D_TEX_ENABLE_MIPMAP_MIN_LOD__SHIFT 26 +#define NV10_3D_TEX_ENABLE_ENABLE 0x40000000 + +#define NV10_3D_TEX_NPOT_PITCH(i0) (0x00000230 + 0x4*(i0)) +#define NV10_3D_TEX_NPOT_PITCH_PITCH__MASK 0xffff0000 +#define NV10_3D_TEX_NPOT_PITCH_PITCH__SHIFT 16 + +#define NV10_3D_TEX_NPOT_SIZE(i0) (0x00000240 + 0x4*(i0)) +#define NV10_3D_TEX_NPOT_SIZE_H__MASK 0x0000ffff +#define NV10_3D_TEX_NPOT_SIZE_H__SHIFT 0 +#define NV10_3D_TEX_NPOT_SIZE_W__MASK 0xffff0000 +#define NV10_3D_TEX_NPOT_SIZE_W__SHIFT 16 + +#define NV10_3D_TEX_FILTER(i0) (0x00000248 + 0x4*(i0)) +#define NV10_3D_TEX_FILTER_LOD_BIAS__MASK 0x00000f00 +#define NV10_3D_TEX_FILTER_LOD_BIAS__SHIFT 8 +#define NV10_3D_TEX_FILTER_MINIFY__MASK 0x0f000000 +#define NV10_3D_TEX_FILTER_MINIFY__SHIFT 24 +#define NV10_3D_TEX_FILTER_MINIFY_NEAREST 0x01000000 +#define NV10_3D_TEX_FILTER_MINIFY_LINEAR 0x02000000 +#define NV10_3D_TEX_FILTER_MINIFY_NEAREST_MIPMAP_NEAREST 0x03000000 +#define NV10_3D_TEX_FILTER_MINIFY_LINEAR_MIPMAP_NEAREST 0x04000000 +#define NV10_3D_TEX_FILTER_MINIFY_NEAREST_MIPMAP_LINEAR 0x05000000 +#define NV10_3D_TEX_FILTER_MINIFY_LINEAR_MIPMAP_LINEAR 0x06000000 +#define NV10_3D_TEX_FILTER_MAGNIFY__MASK 0xf0000000 +#define NV10_3D_TEX_FILTER_MAGNIFY__SHIFT 28 +#define NV10_3D_TEX_FILTER_MAGNIFY_NEAREST 0x10000000 +#define NV10_3D_TEX_FILTER_MAGNIFY_LINEAR 0x20000000 + +#define NV10_3D_TEX_PALETTE_OFFSET(i0) (0x00000250 + 0x4*(i0)) + + + +#define NV10_3D_RC_IN_ALPHA(i0) (0x00000260 + 0x4*(i0)) +#define NV10_3D_RC_IN_ALPHA_D_INPUT__MASK 0x0000000f +#define NV10_3D_RC_IN_ALPHA_D_INPUT__SHIFT 0 +#define NV10_3D_RC_IN_ALPHA_D_INPUT_ZERO 0x00000000 +#define NV10_3D_RC_IN_ALPHA_D_INPUT_CONSTANT_COLOR0 0x00000001 +#define NV10_3D_RC_IN_ALPHA_D_INPUT_CONSTANT_COLOR1 0x00000002 +#define NV10_3D_RC_IN_ALPHA_D_INPUT_FOG 0x00000003 +#define NV10_3D_RC_IN_ALPHA_D_INPUT_PRIMARY_COLOR 0x00000004 +#define NV10_3D_RC_IN_ALPHA_D_INPUT_SECONDARY_COLOR 0x00000005 +#define NV10_3D_RC_IN_ALPHA_D_INPUT_TEXTURE0 0x00000008 +#define NV10_3D_RC_IN_ALPHA_D_INPUT_TEXTURE1 0x00000009 +#define NV10_3D_RC_IN_ALPHA_D_INPUT_TEXTURE2 0x0000000a +#define NV10_3D_RC_IN_ALPHA_D_INPUT_TEXTURE3 0x0000000b +#define NV10_3D_RC_IN_ALPHA_D_INPUT_SPARE0 0x0000000c +#define NV10_3D_RC_IN_ALPHA_D_INPUT_SPARE1 0x0000000d +#define NV10_3D_RC_IN_ALPHA_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e +#define NV10_3D_RC_IN_ALPHA_D_INPUT_E_TIMES_F 0x0000000f +#define NV10_3D_RC_IN_ALPHA_D_COMPONENT_USAGE__MASK 0x00000010 +#define NV10_3D_RC_IN_ALPHA_D_COMPONENT_USAGE__SHIFT 4 +#define NV10_3D_RC_IN_ALPHA_D_COMPONENT_USAGE_BLUE 0x00000000 +#define NV10_3D_RC_IN_ALPHA_D_COMPONENT_USAGE_ALPHA 0x00000010 +#define NV10_3D_RC_IN_ALPHA_D_MAPPING__MASK 0x000000e0 +#define NV10_3D_RC_IN_ALPHA_D_MAPPING__SHIFT 5 +#define NV10_3D_RC_IN_ALPHA_D_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV10_3D_RC_IN_ALPHA_D_MAPPING_UNSIGNED_INVERT 0x00000020 +#define NV10_3D_RC_IN_ALPHA_D_MAPPING_EXPAND_NORMAL 0x00000040 +#define NV10_3D_RC_IN_ALPHA_D_MAPPING_EXPAND_NEGATE 0x00000060 +#define NV10_3D_RC_IN_ALPHA_D_MAPPING_HALF_BIAS_NORMAL 0x00000080 +#define NV10_3D_RC_IN_ALPHA_D_MAPPING_HALF_BIAS_NEGATE 0x000000a0 +#define NV10_3D_RC_IN_ALPHA_D_MAPPING_SIGNED_IDENTITY 0x000000c0 +#define NV10_3D_RC_IN_ALPHA_D_MAPPING_SIGNED_NEGATE 0x000000e0 +#define NV10_3D_RC_IN_ALPHA_C_INPUT__MASK 0x00000f00 +#define NV10_3D_RC_IN_ALPHA_C_INPUT__SHIFT 8 +#define NV10_3D_RC_IN_ALPHA_C_INPUT_ZERO 0x00000000 +#define NV10_3D_RC_IN_ALPHA_C_INPUT_CONSTANT_COLOR0 0x00000100 +#define NV10_3D_RC_IN_ALPHA_C_INPUT_CONSTANT_COLOR1 0x00000200 +#define NV10_3D_RC_IN_ALPHA_C_INPUT_FOG 0x00000300 +#define NV10_3D_RC_IN_ALPHA_C_INPUT_PRIMARY_COLOR 0x00000400 +#define NV10_3D_RC_IN_ALPHA_C_INPUT_SECONDARY_COLOR 0x00000500 +#define NV10_3D_RC_IN_ALPHA_C_INPUT_TEXTURE0 0x00000800 +#define NV10_3D_RC_IN_ALPHA_C_INPUT_TEXTURE1 0x00000900 +#define NV10_3D_RC_IN_ALPHA_C_INPUT_TEXTURE2 0x00000a00 +#define NV10_3D_RC_IN_ALPHA_C_INPUT_TEXTURE3 0x00000b00 +#define NV10_3D_RC_IN_ALPHA_C_INPUT_SPARE0 0x00000c00 +#define NV10_3D_RC_IN_ALPHA_C_INPUT_SPARE1 0x00000d00 +#define NV10_3D_RC_IN_ALPHA_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 +#define NV10_3D_RC_IN_ALPHA_C_INPUT_E_TIMES_F 0x00000f00 +#define NV10_3D_RC_IN_ALPHA_C_COMPONENT_USAGE__MASK 0x00001000 +#define NV10_3D_RC_IN_ALPHA_C_COMPONENT_USAGE__SHIFT 12 +#define NV10_3D_RC_IN_ALPHA_C_COMPONENT_USAGE_BLUE 0x00000000 +#define NV10_3D_RC_IN_ALPHA_C_COMPONENT_USAGE_ALPHA 0x00001000 +#define NV10_3D_RC_IN_ALPHA_C_MAPPING__MASK 0x0000e000 +#define NV10_3D_RC_IN_ALPHA_C_MAPPING__SHIFT 13 +#define NV10_3D_RC_IN_ALPHA_C_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV10_3D_RC_IN_ALPHA_C_MAPPING_UNSIGNED_INVERT 0x00002000 +#define NV10_3D_RC_IN_ALPHA_C_MAPPING_EXPAND_NORMAL 0x00004000 +#define NV10_3D_RC_IN_ALPHA_C_MAPPING_EXPAND_NEGATE 0x00006000 +#define NV10_3D_RC_IN_ALPHA_C_MAPPING_HALF_BIAS_NORMAL 0x00008000 +#define NV10_3D_RC_IN_ALPHA_C_MAPPING_HALF_BIAS_NEGATE 0x0000a000 +#define NV10_3D_RC_IN_ALPHA_C_MAPPING_SIGNED_IDENTITY 0x0000c000 +#define NV10_3D_RC_IN_ALPHA_C_MAPPING_SIGNED_NEGATE 0x0000e000 +#define NV10_3D_RC_IN_ALPHA_B_INPUT__MASK 0x000f0000 +#define NV10_3D_RC_IN_ALPHA_B_INPUT__SHIFT 16 +#define NV10_3D_RC_IN_ALPHA_B_INPUT_ZERO 0x00000000 +#define NV10_3D_RC_IN_ALPHA_B_INPUT_CONSTANT_COLOR0 0x00010000 +#define NV10_3D_RC_IN_ALPHA_B_INPUT_CONSTANT_COLOR1 0x00020000 +#define NV10_3D_RC_IN_ALPHA_B_INPUT_FOG 0x00030000 +#define NV10_3D_RC_IN_ALPHA_B_INPUT_PRIMARY_COLOR 0x00040000 +#define NV10_3D_RC_IN_ALPHA_B_INPUT_SECONDARY_COLOR 0x00050000 +#define NV10_3D_RC_IN_ALPHA_B_INPUT_TEXTURE0 0x00080000 +#define NV10_3D_RC_IN_ALPHA_B_INPUT_TEXTURE1 0x00090000 +#define NV10_3D_RC_IN_ALPHA_B_INPUT_TEXTURE2 0x000a0000 +#define NV10_3D_RC_IN_ALPHA_B_INPUT_TEXTURE3 0x000b0000 +#define NV10_3D_RC_IN_ALPHA_B_INPUT_SPARE0 0x000c0000 +#define NV10_3D_RC_IN_ALPHA_B_INPUT_SPARE1 0x000d0000 +#define NV10_3D_RC_IN_ALPHA_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 +#define NV10_3D_RC_IN_ALPHA_B_INPUT_E_TIMES_F 0x000f0000 +#define NV10_3D_RC_IN_ALPHA_B_COMPONENT_USAGE__MASK 0x00100000 +#define NV10_3D_RC_IN_ALPHA_B_COMPONENT_USAGE__SHIFT 20 +#define NV10_3D_RC_IN_ALPHA_B_COMPONENT_USAGE_BLUE 0x00000000 +#define NV10_3D_RC_IN_ALPHA_B_COMPONENT_USAGE_ALPHA 0x00100000 +#define NV10_3D_RC_IN_ALPHA_B_MAPPING__MASK 0x00e00000 +#define NV10_3D_RC_IN_ALPHA_B_MAPPING__SHIFT 21 +#define NV10_3D_RC_IN_ALPHA_B_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV10_3D_RC_IN_ALPHA_B_MAPPING_UNSIGNED_INVERT 0x00200000 +#define NV10_3D_RC_IN_ALPHA_B_MAPPING_EXPAND_NORMAL 0x00400000 +#define NV10_3D_RC_IN_ALPHA_B_MAPPING_EXPAND_NEGATE 0x00600000 +#define NV10_3D_RC_IN_ALPHA_B_MAPPING_HALF_BIAS_NORMAL 0x00800000 +#define NV10_3D_RC_IN_ALPHA_B_MAPPING_HALF_BIAS_NEGATE 0x00a00000 +#define NV10_3D_RC_IN_ALPHA_B_MAPPING_SIGNED_IDENTITY 0x00c00000 +#define NV10_3D_RC_IN_ALPHA_B_MAPPING_SIGNED_NEGATE 0x00e00000 +#define NV10_3D_RC_IN_ALPHA_A_INPUT__MASK 0x0f000000 +#define NV10_3D_RC_IN_ALPHA_A_INPUT__SHIFT 24 +#define NV10_3D_RC_IN_ALPHA_A_INPUT_ZERO 0x00000000 +#define NV10_3D_RC_IN_ALPHA_A_INPUT_CONSTANT_COLOR0 0x01000000 +#define NV10_3D_RC_IN_ALPHA_A_INPUT_CONSTANT_COLOR1 0x02000000 +#define NV10_3D_RC_IN_ALPHA_A_INPUT_FOG 0x03000000 +#define NV10_3D_RC_IN_ALPHA_A_INPUT_PRIMARY_COLOR 0x04000000 +#define NV10_3D_RC_IN_ALPHA_A_INPUT_SECONDARY_COLOR 0x05000000 +#define NV10_3D_RC_IN_ALPHA_A_INPUT_TEXTURE0 0x08000000 +#define NV10_3D_RC_IN_ALPHA_A_INPUT_TEXTURE1 0x09000000 +#define NV10_3D_RC_IN_ALPHA_A_INPUT_TEXTURE2 0x0a000000 +#define NV10_3D_RC_IN_ALPHA_A_INPUT_TEXTURE3 0x0b000000 +#define NV10_3D_RC_IN_ALPHA_A_INPUT_SPARE0 0x0c000000 +#define NV10_3D_RC_IN_ALPHA_A_INPUT_SPARE1 0x0d000000 +#define NV10_3D_RC_IN_ALPHA_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 +#define NV10_3D_RC_IN_ALPHA_A_INPUT_E_TIMES_F 0x0f000000 +#define NV10_3D_RC_IN_ALPHA_A_COMPONENT_USAGE__MASK 0x10000000 +#define NV10_3D_RC_IN_ALPHA_A_COMPONENT_USAGE__SHIFT 28 +#define NV10_3D_RC_IN_ALPHA_A_COMPONENT_USAGE_BLUE 0x00000000 +#define NV10_3D_RC_IN_ALPHA_A_COMPONENT_USAGE_ALPHA 0x10000000 +#define NV10_3D_RC_IN_ALPHA_A_MAPPING__MASK 0xe0000000 +#define NV10_3D_RC_IN_ALPHA_A_MAPPING__SHIFT 29 +#define NV10_3D_RC_IN_ALPHA_A_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV10_3D_RC_IN_ALPHA_A_MAPPING_UNSIGNED_INVERT 0x20000000 +#define NV10_3D_RC_IN_ALPHA_A_MAPPING_EXPAND_NORMAL 0x40000000 +#define NV10_3D_RC_IN_ALPHA_A_MAPPING_EXPAND_NEGATE 0x60000000 +#define NV10_3D_RC_IN_ALPHA_A_MAPPING_HALF_BIAS_NORMAL 0x80000000 +#define NV10_3D_RC_IN_ALPHA_A_MAPPING_HALF_BIAS_NEGATE 0xa0000000 +#define NV10_3D_RC_IN_ALPHA_A_MAPPING_SIGNED_IDENTITY 0xc0000000 +#define NV10_3D_RC_IN_ALPHA_A_MAPPING_SIGNED_NEGATE 0xe0000000 + +#define NV10_3D_RC_IN_RGB(i0) (0x00000268 + 0x4*(i0)) +#define NV10_3D_RC_IN_RGB_D_INPUT__MASK 0x0000000f +#define NV10_3D_RC_IN_RGB_D_INPUT__SHIFT 0 +#define NV10_3D_RC_IN_RGB_D_INPUT_ZERO 0x00000000 +#define NV10_3D_RC_IN_RGB_D_INPUT_CONSTANT_COLOR0 0x00000001 +#define NV10_3D_RC_IN_RGB_D_INPUT_CONSTANT_COLOR1 0x00000002 +#define NV10_3D_RC_IN_RGB_D_INPUT_FOG 0x00000003 +#define NV10_3D_RC_IN_RGB_D_INPUT_PRIMARY_COLOR 0x00000004 +#define NV10_3D_RC_IN_RGB_D_INPUT_SECONDARY_COLOR 0x00000005 +#define NV10_3D_RC_IN_RGB_D_INPUT_TEXTURE0 0x00000008 +#define NV10_3D_RC_IN_RGB_D_INPUT_TEXTURE1 0x00000009 +#define NV10_3D_RC_IN_RGB_D_INPUT_TEXTURE2 0x0000000a +#define NV10_3D_RC_IN_RGB_D_INPUT_TEXTURE3 0x0000000b +#define NV10_3D_RC_IN_RGB_D_INPUT_SPARE0 0x0000000c +#define NV10_3D_RC_IN_RGB_D_INPUT_SPARE1 0x0000000d +#define NV10_3D_RC_IN_RGB_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e +#define NV10_3D_RC_IN_RGB_D_INPUT_E_TIMES_F 0x0000000f +#define NV10_3D_RC_IN_RGB_D_COMPONENT_USAGE__MASK 0x00000010 +#define NV10_3D_RC_IN_RGB_D_COMPONENT_USAGE__SHIFT 4 +#define NV10_3D_RC_IN_RGB_D_COMPONENT_USAGE_RGB 0x00000000 +#define NV10_3D_RC_IN_RGB_D_COMPONENT_USAGE_ALPHA 0x00000010 +#define NV10_3D_RC_IN_RGB_D_MAPPING__MASK 0x000000e0 +#define NV10_3D_RC_IN_RGB_D_MAPPING__SHIFT 5 +#define NV10_3D_RC_IN_RGB_D_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV10_3D_RC_IN_RGB_D_MAPPING_UNSIGNED_INVERT 0x00000020 +#define NV10_3D_RC_IN_RGB_D_MAPPING_EXPAND_NORMAL 0x00000040 +#define NV10_3D_RC_IN_RGB_D_MAPPING_EXPAND_NEGATE 0x00000060 +#define NV10_3D_RC_IN_RGB_D_MAPPING_HALF_BIAS_NORMAL 0x00000080 +#define NV10_3D_RC_IN_RGB_D_MAPPING_HALF_BIAS_NEGATE 0x000000a0 +#define NV10_3D_RC_IN_RGB_D_MAPPING_SIGNED_IDENTITY 0x000000c0 +#define NV10_3D_RC_IN_RGB_D_MAPPING_SIGNED_NEGATE 0x000000e0 +#define NV10_3D_RC_IN_RGB_C_INPUT__MASK 0x00000f00 +#define NV10_3D_RC_IN_RGB_C_INPUT__SHIFT 8 +#define NV10_3D_RC_IN_RGB_C_INPUT_ZERO 0x00000000 +#define NV10_3D_RC_IN_RGB_C_INPUT_CONSTANT_COLOR0 0x00000100 +#define NV10_3D_RC_IN_RGB_C_INPUT_CONSTANT_COLOR1 0x00000200 +#define NV10_3D_RC_IN_RGB_C_INPUT_FOG 0x00000300 +#define NV10_3D_RC_IN_RGB_C_INPUT_PRIMARY_COLOR 0x00000400 +#define NV10_3D_RC_IN_RGB_C_INPUT_SECONDARY_COLOR 0x00000500 +#define NV10_3D_RC_IN_RGB_C_INPUT_TEXTURE0 0x00000800 +#define NV10_3D_RC_IN_RGB_C_INPUT_TEXTURE1 0x00000900 +#define NV10_3D_RC_IN_RGB_C_INPUT_TEXTURE2 0x00000a00 +#define NV10_3D_RC_IN_RGB_C_INPUT_TEXTURE3 0x00000b00 +#define NV10_3D_RC_IN_RGB_C_INPUT_SPARE0 0x00000c00 +#define NV10_3D_RC_IN_RGB_C_INPUT_SPARE1 0x00000d00 +#define NV10_3D_RC_IN_RGB_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 +#define NV10_3D_RC_IN_RGB_C_INPUT_E_TIMES_F 0x00000f00 +#define NV10_3D_RC_IN_RGB_C_COMPONENT_USAGE__MASK 0x00001000 +#define NV10_3D_RC_IN_RGB_C_COMPONENT_USAGE__SHIFT 12 +#define NV10_3D_RC_IN_RGB_C_COMPONENT_USAGE_RGB 0x00000000 +#define NV10_3D_RC_IN_RGB_C_COMPONENT_USAGE_ALPHA 0x00001000 +#define NV10_3D_RC_IN_RGB_C_MAPPING__MASK 0x0000e000 +#define NV10_3D_RC_IN_RGB_C_MAPPING__SHIFT 13 +#define NV10_3D_RC_IN_RGB_C_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV10_3D_RC_IN_RGB_C_MAPPING_UNSIGNED_INVERT 0x00002000 +#define NV10_3D_RC_IN_RGB_C_MAPPING_EXPAND_NORMAL 0x00004000 +#define NV10_3D_RC_IN_RGB_C_MAPPING_EXPAND_NEGATE 0x00006000 +#define NV10_3D_RC_IN_RGB_C_MAPPING_HALF_BIAS_NORMAL 0x00008000 +#define NV10_3D_RC_IN_RGB_C_MAPPING_HALF_BIAS_NEGATE 0x0000a000 +#define NV10_3D_RC_IN_RGB_C_MAPPING_SIGNED_IDENTITY 0x0000c000 +#define NV10_3D_RC_IN_RGB_C_MAPPING_SIGNED_NEGATE 0x0000e000 +#define NV10_3D_RC_IN_RGB_B_INPUT__MASK 0x000f0000 +#define NV10_3D_RC_IN_RGB_B_INPUT__SHIFT 16 +#define NV10_3D_RC_IN_RGB_B_INPUT_ZERO 0x00000000 +#define NV10_3D_RC_IN_RGB_B_INPUT_CONSTANT_COLOR0 0x00010000 +#define NV10_3D_RC_IN_RGB_B_INPUT_CONSTANT_COLOR1 0x00020000 +#define NV10_3D_RC_IN_RGB_B_INPUT_FOG 0x00030000 +#define NV10_3D_RC_IN_RGB_B_INPUT_PRIMARY_COLOR 0x00040000 +#define NV10_3D_RC_IN_RGB_B_INPUT_SECONDARY_COLOR 0x00050000 +#define NV10_3D_RC_IN_RGB_B_INPUT_TEXTURE0 0x00080000 +#define NV10_3D_RC_IN_RGB_B_INPUT_TEXTURE1 0x00090000 +#define NV10_3D_RC_IN_RGB_B_INPUT_TEXTURE2 0x000a0000 +#define NV10_3D_RC_IN_RGB_B_INPUT_TEXTURE3 0x000b0000 +#define NV10_3D_RC_IN_RGB_B_INPUT_SPARE0 0x000c0000 +#define NV10_3D_RC_IN_RGB_B_INPUT_SPARE1 0x000d0000 +#define NV10_3D_RC_IN_RGB_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 +#define NV10_3D_RC_IN_RGB_B_INPUT_E_TIMES_F 0x000f0000 +#define NV10_3D_RC_IN_RGB_B_COMPONENT_USAGE__MASK 0x00100000 +#define NV10_3D_RC_IN_RGB_B_COMPONENT_USAGE__SHIFT 20 +#define NV10_3D_RC_IN_RGB_B_COMPONENT_USAGE_RGB 0x00000000 +#define NV10_3D_RC_IN_RGB_B_COMPONENT_USAGE_ALPHA 0x00100000 +#define NV10_3D_RC_IN_RGB_B_MAPPING__MASK 0x00e00000 +#define NV10_3D_RC_IN_RGB_B_MAPPING__SHIFT 21 +#define NV10_3D_RC_IN_RGB_B_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV10_3D_RC_IN_RGB_B_MAPPING_UNSIGNED_INVERT 0x00200000 +#define NV10_3D_RC_IN_RGB_B_MAPPING_EXPAND_NORMAL 0x00400000 +#define NV10_3D_RC_IN_RGB_B_MAPPING_EXPAND_NEGATE 0x00600000 +#define NV10_3D_RC_IN_RGB_B_MAPPING_HALF_BIAS_NORMAL 0x00800000 +#define NV10_3D_RC_IN_RGB_B_MAPPING_HALF_BIAS_NEGATE 0x00a00000 +#define NV10_3D_RC_IN_RGB_B_MAPPING_SIGNED_IDENTITY 0x00c00000 +#define NV10_3D_RC_IN_RGB_B_MAPPING_SIGNED_NEGATE 0x00e00000 +#define NV10_3D_RC_IN_RGB_A_INPUT__MASK 0x0f000000 +#define NV10_3D_RC_IN_RGB_A_INPUT__SHIFT 24 +#define NV10_3D_RC_IN_RGB_A_INPUT_ZERO 0x00000000 +#define NV10_3D_RC_IN_RGB_A_INPUT_CONSTANT_COLOR0 0x01000000 +#define NV10_3D_RC_IN_RGB_A_INPUT_CONSTANT_COLOR1 0x02000000 +#define NV10_3D_RC_IN_RGB_A_INPUT_FOG 0x03000000 +#define NV10_3D_RC_IN_RGB_A_INPUT_PRIMARY_COLOR 0x04000000 +#define NV10_3D_RC_IN_RGB_A_INPUT_SECONDARY_COLOR 0x05000000 +#define NV10_3D_RC_IN_RGB_A_INPUT_TEXTURE0 0x08000000 +#define NV10_3D_RC_IN_RGB_A_INPUT_TEXTURE1 0x09000000 +#define NV10_3D_RC_IN_RGB_A_INPUT_TEXTURE2 0x0a000000 +#define NV10_3D_RC_IN_RGB_A_INPUT_TEXTURE3 0x0b000000 +#define NV10_3D_RC_IN_RGB_A_INPUT_SPARE0 0x0c000000 +#define NV10_3D_RC_IN_RGB_A_INPUT_SPARE1 0x0d000000 +#define NV10_3D_RC_IN_RGB_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 +#define NV10_3D_RC_IN_RGB_A_INPUT_E_TIMES_F 0x0f000000 +#define NV10_3D_RC_IN_RGB_A_COMPONENT_USAGE__MASK 0x10000000 +#define NV10_3D_RC_IN_RGB_A_COMPONENT_USAGE__SHIFT 28 +#define NV10_3D_RC_IN_RGB_A_COMPONENT_USAGE_RGB 0x00000000 +#define NV10_3D_RC_IN_RGB_A_COMPONENT_USAGE_ALPHA 0x10000000 +#define NV10_3D_RC_IN_RGB_A_MAPPING__MASK 0xe0000000 +#define NV10_3D_RC_IN_RGB_A_MAPPING__SHIFT 29 +#define NV10_3D_RC_IN_RGB_A_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV10_3D_RC_IN_RGB_A_MAPPING_UNSIGNED_INVERT 0x20000000 +#define NV10_3D_RC_IN_RGB_A_MAPPING_EXPAND_NORMAL 0x40000000 +#define NV10_3D_RC_IN_RGB_A_MAPPING_EXPAND_NEGATE 0x60000000 +#define NV10_3D_RC_IN_RGB_A_MAPPING_HALF_BIAS_NORMAL 0x80000000 +#define NV10_3D_RC_IN_RGB_A_MAPPING_HALF_BIAS_NEGATE 0xa0000000 +#define NV10_3D_RC_IN_RGB_A_MAPPING_SIGNED_IDENTITY 0xc0000000 +#define NV10_3D_RC_IN_RGB_A_MAPPING_SIGNED_NEGATE 0xe0000000 + +#define NV10_3D_RC_COLOR(i0) (0x00000270 + 0x4*(i0)) +#define NV10_3D_RC_COLOR_B__MASK 0x000000ff +#define NV10_3D_RC_COLOR_B__SHIFT 0 +#define NV10_3D_RC_COLOR_G__MASK 0x0000ff00 +#define NV10_3D_RC_COLOR_G__SHIFT 8 +#define NV10_3D_RC_COLOR_R__MASK 0x00ff0000 +#define NV10_3D_RC_COLOR_R__SHIFT 16 +#define NV10_3D_RC_COLOR_A__MASK 0xff000000 +#define NV10_3D_RC_COLOR_A__SHIFT 24 + +#define NV10_3D_RC_OUT_ALPHA(i0) (0x00000278 + 0x4*(i0)) +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT__MASK 0x0000000f +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT__SHIFT 0 +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT_ZERO 0x00000000 +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT_CONSTANT_COLOR0 0x00000001 +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT_CONSTANT_COLOR1 0x00000002 +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT_FOG 0x00000003 +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT_PRIMARY_COLOR 0x00000004 +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT_SECONDARY_COLOR 0x00000005 +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE0 0x00000008 +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE1 0x00000009 +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE2 0x0000000a +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE3 0x0000000b +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT_SPARE0 0x0000000c +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT_SPARE1 0x0000000d +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e +#define NV10_3D_RC_OUT_ALPHA_CD_OUTPUT_E_TIMES_F 0x0000000f +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT__MASK 0x000000f0 +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT__SHIFT 4 +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT_ZERO 0x00000000 +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT_CONSTANT_COLOR0 0x00000010 +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT_CONSTANT_COLOR1 0x00000020 +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT_FOG 0x00000030 +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT_PRIMARY_COLOR 0x00000040 +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT_SECONDARY_COLOR 0x00000050 +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE0 0x00000080 +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE1 0x00000090 +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE2 0x000000a0 +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE3 0x000000b0 +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT_SPARE0 0x000000c0 +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT_SPARE1 0x000000d0 +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000000e0 +#define NV10_3D_RC_OUT_ALPHA_AB_OUTPUT_E_TIMES_F 0x000000f0 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT__MASK 0x00000f00 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT__SHIFT 8 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT_ZERO 0x00000000 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT_CONSTANT_COLOR0 0x00000100 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT_CONSTANT_COLOR1 0x00000200 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT_FOG 0x00000300 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT_PRIMARY_COLOR 0x00000400 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT_SECONDARY_COLOR 0x00000500 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE0 0x00000800 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE1 0x00000900 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE2 0x00000a00 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE3 0x00000b00 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT_SPARE0 0x00000c00 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT_SPARE1 0x00000d00 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 +#define NV10_3D_RC_OUT_ALPHA_SUM_OUTPUT_E_TIMES_F 0x00000f00 +#define NV10_3D_RC_OUT_ALPHA_CD_DOT_PRODUCT 0x00001000 +#define NV10_3D_RC_OUT_ALPHA_AB_DOT_PRODUCT 0x00002000 +#define NV10_3D_RC_OUT_ALPHA_MUX_SUM 0x00004000 +#define NV10_3D_RC_OUT_ALPHA_BIAS__MASK 0x00008000 +#define NV10_3D_RC_OUT_ALPHA_BIAS__SHIFT 15 +#define NV10_3D_RC_OUT_ALPHA_BIAS_NONE 0x00000000 +#define NV10_3D_RC_OUT_ALPHA_BIAS_BIAS_BY_NEGATIVE_ONE_HALF 0x00008000 +#define NV10_3D_RC_OUT_ALPHA_SCALE__MASK 0x00030000 +#define NV10_3D_RC_OUT_ALPHA_SCALE__SHIFT 16 +#define NV10_3D_RC_OUT_ALPHA_SCALE_NONE 0x00000000 +#define NV10_3D_RC_OUT_ALPHA_SCALE_SCALE_BY_TWO 0x00010000 +#define NV10_3D_RC_OUT_ALPHA_SCALE_SCALE_BY_FOUR 0x00020000 +#define NV10_3D_RC_OUT_ALPHA_SCALE_SCALE_BY_ONE_HALF 0x00030000 + +#define NV10_3D_RC_OUT_RGB(i0) (0x00000280 + 0x4*(i0)) +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT__MASK 0x0000000f +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT__SHIFT 0 +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT_ZERO 0x00000000 +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT_CONSTANT_COLOR0 0x00000001 +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT_CONSTANT_COLOR1 0x00000002 +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT_FOG 0x00000003 +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT_PRIMARY_COLOR 0x00000004 +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT_SECONDARY_COLOR 0x00000005 +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT_TEXTURE0 0x00000008 +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT_TEXTURE1 0x00000009 +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT_TEXTURE2 0x0000000a +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT_TEXTURE3 0x0000000b +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT_SPARE0 0x0000000c +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT_SPARE1 0x0000000d +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e +#define NV10_3D_RC_OUT_RGB_CD_OUTPUT_E_TIMES_F 0x0000000f +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT__MASK 0x000000f0 +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT__SHIFT 4 +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT_ZERO 0x00000000 +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT_CONSTANT_COLOR0 0x00000010 +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT_CONSTANT_COLOR1 0x00000020 +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT_FOG 0x00000030 +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT_PRIMARY_COLOR 0x00000040 +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT_SECONDARY_COLOR 0x00000050 +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT_TEXTURE0 0x00000080 +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT_TEXTURE1 0x00000090 +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT_TEXTURE2 0x000000a0 +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT_TEXTURE3 0x000000b0 +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT_SPARE0 0x000000c0 +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT_SPARE1 0x000000d0 +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000000e0 +#define NV10_3D_RC_OUT_RGB_AB_OUTPUT_E_TIMES_F 0x000000f0 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT__MASK 0x00000f00 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT__SHIFT 8 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT_ZERO 0x00000000 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT_CONSTANT_COLOR0 0x00000100 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT_CONSTANT_COLOR1 0x00000200 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT_FOG 0x00000300 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT_PRIMARY_COLOR 0x00000400 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT_SECONDARY_COLOR 0x00000500 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT_TEXTURE0 0x00000800 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT_TEXTURE1 0x00000900 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT_TEXTURE2 0x00000a00 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT_TEXTURE3 0x00000b00 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT_SPARE0 0x00000c00 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT_SPARE1 0x00000d00 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 +#define NV10_3D_RC_OUT_RGB_SUM_OUTPUT_E_TIMES_F 0x00000f00 +#define NV10_3D_RC_OUT_RGB_CD_DOT_PRODUCT 0x00001000 +#define NV10_3D_RC_OUT_RGB_AB_DOT_PRODUCT 0x00002000 +#define NV10_3D_RC_OUT_RGB_MUX_SUM 0x00004000 +#define NV10_3D_RC_OUT_RGB_BIAS__MASK 0x00008000 +#define NV10_3D_RC_OUT_RGB_BIAS__SHIFT 15 +#define NV10_3D_RC_OUT_RGB_BIAS_NONE 0x00000000 +#define NV10_3D_RC_OUT_RGB_BIAS_BIAS_BY_NEGATIVE_ONE_HALF 0x00008000 +#define NV10_3D_RC_OUT_RGB_SCALE__MASK 0x00030000 +#define NV10_3D_RC_OUT_RGB_SCALE__SHIFT 16 +#define NV10_3D_RC_OUT_RGB_SCALE_NONE 0x00000000 +#define NV10_3D_RC_OUT_RGB_SCALE_SCALE_BY_TWO 0x00010000 +#define NV10_3D_RC_OUT_RGB_SCALE_SCALE_BY_FOUR 0x00020000 +#define NV10_3D_RC_OUT_RGB_SCALE_SCALE_BY_ONE_HALF 0x00030000 +#define NV10_3D_RC_OUT_RGB_OPERATION__MASK 0x38000000 +#define NV10_3D_RC_OUT_RGB_OPERATION__SHIFT 27 + +#define NV10_3D_RC_FINAL0 0x00000288 +#define NV10_3D_RC_FINAL0_D_INPUT__MASK 0x0000000f +#define NV10_3D_RC_FINAL0_D_INPUT__SHIFT 0 +#define NV10_3D_RC_FINAL0_D_INPUT_ZERO 0x00000000 +#define NV10_3D_RC_FINAL0_D_INPUT_CONSTANT_COLOR0 0x00000001 +#define NV10_3D_RC_FINAL0_D_INPUT_CONSTANT_COLOR1 0x00000002 +#define NV10_3D_RC_FINAL0_D_INPUT_FOG 0x00000003 +#define NV10_3D_RC_FINAL0_D_INPUT_PRIMARY_COLOR 0x00000004 +#define NV10_3D_RC_FINAL0_D_INPUT_SECONDARY_COLOR 0x00000005 +#define NV10_3D_RC_FINAL0_D_INPUT_TEXTURE0 0x00000008 +#define NV10_3D_RC_FINAL0_D_INPUT_TEXTURE1 0x00000009 +#define NV10_3D_RC_FINAL0_D_INPUT_TEXTURE2 0x0000000a +#define NV10_3D_RC_FINAL0_D_INPUT_TEXTURE3 0x0000000b +#define NV10_3D_RC_FINAL0_D_INPUT_SPARE0 0x0000000c +#define NV10_3D_RC_FINAL0_D_INPUT_SPARE1 0x0000000d +#define NV10_3D_RC_FINAL0_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e +#define NV10_3D_RC_FINAL0_D_INPUT_E_TIMES_F 0x0000000f +#define NV10_3D_RC_FINAL0_D_COMPONENT_USAGE__MASK 0x00000010 +#define NV10_3D_RC_FINAL0_D_COMPONENT_USAGE__SHIFT 4 +#define NV10_3D_RC_FINAL0_D_COMPONENT_USAGE_RGB 0x00000000 +#define NV10_3D_RC_FINAL0_D_COMPONENT_USAGE_ALPHA 0x00000010 +#define NV10_3D_RC_FINAL0_D_MAPPING__MASK 0x000000e0 +#define NV10_3D_RC_FINAL0_D_MAPPING__SHIFT 5 +#define NV10_3D_RC_FINAL0_D_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV10_3D_RC_FINAL0_D_MAPPING_UNSIGNED_INVERT 0x00000020 +#define NV10_3D_RC_FINAL0_D_MAPPING_EXPAND_NORMAL 0x00000040 +#define NV10_3D_RC_FINAL0_D_MAPPING_EXPAND_NEGATE 0x00000060 +#define NV10_3D_RC_FINAL0_D_MAPPING_HALF_BIAS_NORMAL 0x00000080 +#define NV10_3D_RC_FINAL0_D_MAPPING_HALF_BIAS_NEGATE 0x000000a0 +#define NV10_3D_RC_FINAL0_D_MAPPING_SIGNED_IDENTITY 0x000000c0 +#define NV10_3D_RC_FINAL0_D_MAPPING_SIGNED_NEGATE 0x000000e0 +#define NV10_3D_RC_FINAL0_C_INPUT__MASK 0x00000f00 +#define NV10_3D_RC_FINAL0_C_INPUT__SHIFT 8 +#define NV10_3D_RC_FINAL0_C_INPUT_ZERO 0x00000000 +#define NV10_3D_RC_FINAL0_C_INPUT_CONSTANT_COLOR0 0x00000100 +#define NV10_3D_RC_FINAL0_C_INPUT_CONSTANT_COLOR1 0x00000200 +#define NV10_3D_RC_FINAL0_C_INPUT_FOG 0x00000300 +#define NV10_3D_RC_FINAL0_C_INPUT_PRIMARY_COLOR 0x00000400 +#define NV10_3D_RC_FINAL0_C_INPUT_SECONDARY_COLOR 0x00000500 +#define NV10_3D_RC_FINAL0_C_INPUT_TEXTURE0 0x00000800 +#define NV10_3D_RC_FINAL0_C_INPUT_TEXTURE1 0x00000900 +#define NV10_3D_RC_FINAL0_C_INPUT_TEXTURE2 0x00000a00 +#define NV10_3D_RC_FINAL0_C_INPUT_TEXTURE3 0x00000b00 +#define NV10_3D_RC_FINAL0_C_INPUT_SPARE0 0x00000c00 +#define NV10_3D_RC_FINAL0_C_INPUT_SPARE1 0x00000d00 +#define NV10_3D_RC_FINAL0_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 +#define NV10_3D_RC_FINAL0_C_INPUT_E_TIMES_F 0x00000f00 +#define NV10_3D_RC_FINAL0_C_COMPONENT_USAGE__MASK 0x00001000 +#define NV10_3D_RC_FINAL0_C_COMPONENT_USAGE__SHIFT 12 +#define NV10_3D_RC_FINAL0_C_COMPONENT_USAGE_RGB 0x00000000 +#define NV10_3D_RC_FINAL0_C_COMPONENT_USAGE_ALPHA 0x00001000 +#define NV10_3D_RC_FINAL0_C_MAPPING__MASK 0x0000e000 +#define NV10_3D_RC_FINAL0_C_MAPPING__SHIFT 13 +#define NV10_3D_RC_FINAL0_C_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV10_3D_RC_FINAL0_C_MAPPING_UNSIGNED_INVERT 0x00002000 +#define NV10_3D_RC_FINAL0_C_MAPPING_EXPAND_NORMAL 0x00004000 +#define NV10_3D_RC_FINAL0_C_MAPPING_EXPAND_NEGATE 0x00006000 +#define NV10_3D_RC_FINAL0_C_MAPPING_HALF_BIAS_NORMAL 0x00008000 +#define NV10_3D_RC_FINAL0_C_MAPPING_HALF_BIAS_NEGATE 0x0000a000 +#define NV10_3D_RC_FINAL0_C_MAPPING_SIGNED_IDENTITY 0x0000c000 +#define NV10_3D_RC_FINAL0_C_MAPPING_SIGNED_NEGATE 0x0000e000 +#define NV10_3D_RC_FINAL0_B_INPUT__MASK 0x000f0000 +#define NV10_3D_RC_FINAL0_B_INPUT__SHIFT 16 +#define NV10_3D_RC_FINAL0_B_INPUT_ZERO 0x00000000 +#define NV10_3D_RC_FINAL0_B_INPUT_CONSTANT_COLOR0 0x00010000 +#define NV10_3D_RC_FINAL0_B_INPUT_CONSTANT_COLOR1 0x00020000 +#define NV10_3D_RC_FINAL0_B_INPUT_FOG 0x00030000 +#define NV10_3D_RC_FINAL0_B_INPUT_PRIMARY_COLOR 0x00040000 +#define NV10_3D_RC_FINAL0_B_INPUT_SECONDARY_COLOR 0x00050000 +#define NV10_3D_RC_FINAL0_B_INPUT_TEXTURE0 0x00080000 +#define NV10_3D_RC_FINAL0_B_INPUT_TEXTURE1 0x00090000 +#define NV10_3D_RC_FINAL0_B_INPUT_TEXTURE2 0x000a0000 +#define NV10_3D_RC_FINAL0_B_INPUT_TEXTURE3 0x000b0000 +#define NV10_3D_RC_FINAL0_B_INPUT_SPARE0 0x000c0000 +#define NV10_3D_RC_FINAL0_B_INPUT_SPARE1 0x000d0000 +#define NV10_3D_RC_FINAL0_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 +#define NV10_3D_RC_FINAL0_B_INPUT_E_TIMES_F 0x000f0000 +#define NV10_3D_RC_FINAL0_B_COMPONENT_USAGE__MASK 0x00100000 +#define NV10_3D_RC_FINAL0_B_COMPONENT_USAGE__SHIFT 20 +#define NV10_3D_RC_FINAL0_B_COMPONENT_USAGE_RGB 0x00000000 +#define NV10_3D_RC_FINAL0_B_COMPONENT_USAGE_ALPHA 0x00100000 +#define NV10_3D_RC_FINAL0_B_MAPPING__MASK 0x00e00000 +#define NV10_3D_RC_FINAL0_B_MAPPING__SHIFT 21 +#define NV10_3D_RC_FINAL0_B_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV10_3D_RC_FINAL0_B_MAPPING_UNSIGNED_INVERT 0x00200000 +#define NV10_3D_RC_FINAL0_B_MAPPING_EXPAND_NORMAL 0x00400000 +#define NV10_3D_RC_FINAL0_B_MAPPING_EXPAND_NEGATE 0x00600000 +#define NV10_3D_RC_FINAL0_B_MAPPING_HALF_BIAS_NORMAL 0x00800000 +#define NV10_3D_RC_FINAL0_B_MAPPING_HALF_BIAS_NEGATE 0x00a00000 +#define NV10_3D_RC_FINAL0_B_MAPPING_SIGNED_IDENTITY 0x00c00000 +#define NV10_3D_RC_FINAL0_B_MAPPING_SIGNED_NEGATE 0x00e00000 +#define NV10_3D_RC_FINAL0_A_INPUT__MASK 0x0f000000 +#define NV10_3D_RC_FINAL0_A_INPUT__SHIFT 24 +#define NV10_3D_RC_FINAL0_A_INPUT_ZERO 0x00000000 +#define NV10_3D_RC_FINAL0_A_INPUT_CONSTANT_COLOR0 0x01000000 +#define NV10_3D_RC_FINAL0_A_INPUT_CONSTANT_COLOR1 0x02000000 +#define NV10_3D_RC_FINAL0_A_INPUT_FOG 0x03000000 +#define NV10_3D_RC_FINAL0_A_INPUT_PRIMARY_COLOR 0x04000000 +#define NV10_3D_RC_FINAL0_A_INPUT_SECONDARY_COLOR 0x05000000 +#define NV10_3D_RC_FINAL0_A_INPUT_TEXTURE0 0x08000000 +#define NV10_3D_RC_FINAL0_A_INPUT_TEXTURE1 0x09000000 +#define NV10_3D_RC_FINAL0_A_INPUT_TEXTURE2 0x0a000000 +#define NV10_3D_RC_FINAL0_A_INPUT_TEXTURE3 0x0b000000 +#define NV10_3D_RC_FINAL0_A_INPUT_SPARE0 0x0c000000 +#define NV10_3D_RC_FINAL0_A_INPUT_SPARE1 0x0d000000 +#define NV10_3D_RC_FINAL0_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 +#define NV10_3D_RC_FINAL0_A_INPUT_E_TIMES_F 0x0f000000 +#define NV10_3D_RC_FINAL0_A_COMPONENT_USAGE__MASK 0x10000000 +#define NV10_3D_RC_FINAL0_A_COMPONENT_USAGE__SHIFT 28 +#define NV10_3D_RC_FINAL0_A_COMPONENT_USAGE_RGB 0x00000000 +#define NV10_3D_RC_FINAL0_A_COMPONENT_USAGE_ALPHA 0x10000000 +#define NV10_3D_RC_FINAL0_A_MAPPING__MASK 0xe0000000 +#define NV10_3D_RC_FINAL0_A_MAPPING__SHIFT 29 +#define NV10_3D_RC_FINAL0_A_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV10_3D_RC_FINAL0_A_MAPPING_UNSIGNED_INVERT 0x20000000 +#define NV10_3D_RC_FINAL0_A_MAPPING_EXPAND_NORMAL 0x40000000 +#define NV10_3D_RC_FINAL0_A_MAPPING_EXPAND_NEGATE 0x60000000 +#define NV10_3D_RC_FINAL0_A_MAPPING_HALF_BIAS_NORMAL 0x80000000 +#define NV10_3D_RC_FINAL0_A_MAPPING_HALF_BIAS_NEGATE 0xa0000000 +#define NV10_3D_RC_FINAL0_A_MAPPING_SIGNED_IDENTITY 0xc0000000 +#define NV10_3D_RC_FINAL0_A_MAPPING_SIGNED_NEGATE 0xe0000000 + +#define NV10_3D_RC_FINAL1 0x0000028c +#define NV10_3D_RC_FINAL1_COLOR_SUM_CLAMP 0x00000080 +#define NV10_3D_RC_FINAL1_G_INPUT__MASK 0x00000f00 +#define NV10_3D_RC_FINAL1_G_INPUT__SHIFT 8 +#define NV10_3D_RC_FINAL1_G_INPUT_ZERO 0x00000000 +#define NV10_3D_RC_FINAL1_G_INPUT_CONSTANT_COLOR0 0x00000100 +#define NV10_3D_RC_FINAL1_G_INPUT_CONSTANT_COLOR1 0x00000200 +#define NV10_3D_RC_FINAL1_G_INPUT_FOG 0x00000300 +#define NV10_3D_RC_FINAL1_G_INPUT_PRIMARY_COLOR 0x00000400 +#define NV10_3D_RC_FINAL1_G_INPUT_SECONDARY_COLOR 0x00000500 +#define NV10_3D_RC_FINAL1_G_INPUT_TEXTURE0 0x00000800 +#define NV10_3D_RC_FINAL1_G_INPUT_TEXTURE1 0x00000900 +#define NV10_3D_RC_FINAL1_G_INPUT_TEXTURE2 0x00000a00 +#define NV10_3D_RC_FINAL1_G_INPUT_TEXTURE3 0x00000b00 +#define NV10_3D_RC_FINAL1_G_INPUT_SPARE0 0x00000c00 +#define NV10_3D_RC_FINAL1_G_INPUT_SPARE1 0x00000d00 +#define NV10_3D_RC_FINAL1_G_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 +#define NV10_3D_RC_FINAL1_G_INPUT_E_TIMES_F 0x00000f00 +#define NV10_3D_RC_FINAL1_G_COMPONENT_USAGE__MASK 0x00001000 +#define NV10_3D_RC_FINAL1_G_COMPONENT_USAGE__SHIFT 12 +#define NV10_3D_RC_FINAL1_G_COMPONENT_USAGE_RGB 0x00000000 +#define NV10_3D_RC_FINAL1_G_COMPONENT_USAGE_ALPHA 0x00001000 +#define NV10_3D_RC_FINAL1_G_MAPPING__MASK 0x0000e000 +#define NV10_3D_RC_FINAL1_G_MAPPING__SHIFT 13 +#define NV10_3D_RC_FINAL1_G_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV10_3D_RC_FINAL1_G_MAPPING_UNSIGNED_INVERT 0x00002000 +#define NV10_3D_RC_FINAL1_G_MAPPING_EXPAND_NORMAL 0x00004000 +#define NV10_3D_RC_FINAL1_G_MAPPING_EXPAND_NEGATE 0x00006000 +#define NV10_3D_RC_FINAL1_G_MAPPING_HALF_BIAS_NORMAL 0x00008000 +#define NV10_3D_RC_FINAL1_G_MAPPING_HALF_BIAS_NEGATE 0x0000a000 +#define NV10_3D_RC_FINAL1_G_MAPPING_SIGNED_IDENTITY 0x0000c000 +#define NV10_3D_RC_FINAL1_G_MAPPING_SIGNED_NEGATE 0x0000e000 +#define NV10_3D_RC_FINAL1_F_INPUT__MASK 0x000f0000 +#define NV10_3D_RC_FINAL1_F_INPUT__SHIFT 16 +#define NV10_3D_RC_FINAL1_F_INPUT_ZERO 0x00000000 +#define NV10_3D_RC_FINAL1_F_INPUT_CONSTANT_COLOR0 0x00010000 +#define NV10_3D_RC_FINAL1_F_INPUT_CONSTANT_COLOR1 0x00020000 +#define NV10_3D_RC_FINAL1_F_INPUT_FOG 0x00030000 +#define NV10_3D_RC_FINAL1_F_INPUT_PRIMARY_COLOR 0x00040000 +#define NV10_3D_RC_FINAL1_F_INPUT_SECONDARY_COLOR 0x00050000 +#define NV10_3D_RC_FINAL1_F_INPUT_TEXTURE0 0x00080000 +#define NV10_3D_RC_FINAL1_F_INPUT_TEXTURE1 0x00090000 +#define NV10_3D_RC_FINAL1_F_INPUT_TEXTURE2 0x000a0000 +#define NV10_3D_RC_FINAL1_F_INPUT_TEXTURE3 0x000b0000 +#define NV10_3D_RC_FINAL1_F_INPUT_SPARE0 0x000c0000 +#define NV10_3D_RC_FINAL1_F_INPUT_SPARE1 0x000d0000 +#define NV10_3D_RC_FINAL1_F_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 +#define NV10_3D_RC_FINAL1_F_INPUT_E_TIMES_F 0x000f0000 +#define NV10_3D_RC_FINAL1_F_COMPONENT_USAGE__MASK 0x00100000 +#define NV10_3D_RC_FINAL1_F_COMPONENT_USAGE__SHIFT 20 +#define NV10_3D_RC_FINAL1_F_COMPONENT_USAGE_RGB 0x00000000 +#define NV10_3D_RC_FINAL1_F_COMPONENT_USAGE_ALPHA 0x00100000 +#define NV10_3D_RC_FINAL1_F_MAPPING__MASK 0x00e00000 +#define NV10_3D_RC_FINAL1_F_MAPPING__SHIFT 21 +#define NV10_3D_RC_FINAL1_F_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV10_3D_RC_FINAL1_F_MAPPING_UNSIGNED_INVERT 0x00200000 +#define NV10_3D_RC_FINAL1_F_MAPPING_EXPAND_NORMAL 0x00400000 +#define NV10_3D_RC_FINAL1_F_MAPPING_EXPAND_NEGATE 0x00600000 +#define NV10_3D_RC_FINAL1_F_MAPPING_HALF_BIAS_NORMAL 0x00800000 +#define NV10_3D_RC_FINAL1_F_MAPPING_HALF_BIAS_NEGATE 0x00a00000 +#define NV10_3D_RC_FINAL1_F_MAPPING_SIGNED_IDENTITY 0x00c00000 +#define NV10_3D_RC_FINAL1_F_MAPPING_SIGNED_NEGATE 0x00e00000 +#define NV10_3D_RC_FINAL1_E_INPUT__MASK 0x0f000000 +#define NV10_3D_RC_FINAL1_E_INPUT__SHIFT 24 +#define NV10_3D_RC_FINAL1_E_INPUT_ZERO 0x00000000 +#define NV10_3D_RC_FINAL1_E_INPUT_CONSTANT_COLOR0 0x01000000 +#define NV10_3D_RC_FINAL1_E_INPUT_CONSTANT_COLOR1 0x02000000 +#define NV10_3D_RC_FINAL1_E_INPUT_FOG 0x03000000 +#define NV10_3D_RC_FINAL1_E_INPUT_PRIMARY_COLOR 0x04000000 +#define NV10_3D_RC_FINAL1_E_INPUT_SECONDARY_COLOR 0x05000000 +#define NV10_3D_RC_FINAL1_E_INPUT_TEXTURE0 0x08000000 +#define NV10_3D_RC_FINAL1_E_INPUT_TEXTURE1 0x09000000 +#define NV10_3D_RC_FINAL1_E_INPUT_TEXTURE2 0x0a000000 +#define NV10_3D_RC_FINAL1_E_INPUT_TEXTURE3 0x0b000000 +#define NV10_3D_RC_FINAL1_E_INPUT_SPARE0 0x0c000000 +#define NV10_3D_RC_FINAL1_E_INPUT_SPARE1 0x0d000000 +#define NV10_3D_RC_FINAL1_E_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 +#define NV10_3D_RC_FINAL1_E_INPUT_E_TIMES_F 0x0f000000 +#define NV10_3D_RC_FINAL1_E_COMPONENT_USAGE__MASK 0x10000000 +#define NV10_3D_RC_FINAL1_E_COMPONENT_USAGE__SHIFT 28 +#define NV10_3D_RC_FINAL1_E_COMPONENT_USAGE_RGB 0x00000000 +#define NV10_3D_RC_FINAL1_E_COMPONENT_USAGE_ALPHA 0x10000000 +#define NV10_3D_RC_FINAL1_E_MAPPING__MASK 0xe0000000 +#define NV10_3D_RC_FINAL1_E_MAPPING__SHIFT 29 +#define NV10_3D_RC_FINAL1_E_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV10_3D_RC_FINAL1_E_MAPPING_UNSIGNED_INVERT 0x20000000 +#define NV10_3D_RC_FINAL1_E_MAPPING_EXPAND_NORMAL 0x40000000 +#define NV10_3D_RC_FINAL1_E_MAPPING_EXPAND_NEGATE 0x60000000 +#define NV10_3D_RC_FINAL1_E_MAPPING_HALF_BIAS_NORMAL 0x80000000 +#define NV10_3D_RC_FINAL1_E_MAPPING_HALF_BIAS_NEGATE 0xa0000000 +#define NV10_3D_RC_FINAL1_E_MAPPING_SIGNED_IDENTITY 0xc0000000 +#define NV10_3D_RC_FINAL1_E_MAPPING_SIGNED_NEGATE 0xe0000000 + + +#define NV17_3D_DMA_HIERZ 0x000001b0 + +#define NV17_3D_HIERZ_PITCH 0x00000d5c + +#define NV17_3D_HIERZ_OFFSET 0x00000d60 + +#define NV17_3D_HIERZ_FILL_VALUE 0x00000d68 + +#define NV17_3D_HIERZ_BUFFER_CLEAR 0x00000d6c + +#define NV17_3D_UNK0D74 0x00000d74 + +#define NV17_3D_UNK0D84 0x00000d84 + + +#define NV17_3D_HIERZ_WINDOW 0x00001638 + + +#define NV17_3D_HIERZ_WINDOW_X 0x00001638 + +#define NV17_3D_HIERZ_WINDOW_Y 0x0000163c + +#define NV17_3D_HIERZ_WINDOW_Z 0x00001640 + +#define NV17_3D_HIERZ_WINDOW_W 0x00001644 + +#define NV17_3D_HIERZ_ENABLE 0x00001658 + + +#define NV17_3D_UNK01AC 0x000001ac + +#define NV17_3D_UNK0258 0x00000258 + +#define NV17_3D_UNK025C 0x0000025c + +#define NV10_3D_UNK0290 0x00000290 + +#define NV17_3D_COLOR_MASK_ENABLE 0x000002bc + +#define NV10_3D_UNK03F0 0x000003f0 + +#define NV10_3D_UNK03F4 0x000003f4 + +#define NV17_3D_ZCLEAR_ENABLE 0x000003f8 + +#define NV17_3D_ZCLEAR_VALUE 0x000003fc +#define NV17_3D_ZCLEAR_VALUE_DEPTH__MASK 0xffffff00 +#define NV17_3D_ZCLEAR_VALUE_DEPTH__SHIFT 8 +#define NV17_3D_ZCLEAR_VALUE_SEQUENCE__MASK 0x000000ff +#define NV17_3D_ZCLEAR_VALUE_SEQUENCE__SHIFT 0 + +#define NV10_3D_POINT_SIZE 0x000003ec + +#define NV10_3D_POINT_PARAMETER(i0) (0x000006f8 + 0x4*(i0)) +#define NV10_3D_POINT_PARAMETER__ESIZE 0x00000004 +#define NV10_3D_POINT_PARAMETER__LEN 0x00000008 + +#define NV11_3D_COLOR_LOGIC_OP 0x00000d40 + +#define NV11_3D_COLOR_LOGIC_OP_ENABLE 0x00000d40 + +#define NV11_3D_COLOR_LOGIC_OP_OP 0x00000d44 +#define NV11_3D_COLOR_LOGIC_OP_OP_CLEAR 0x00001500 +#define NV11_3D_COLOR_LOGIC_OP_OP_AND 0x00001501 +#define NV11_3D_COLOR_LOGIC_OP_OP_AND_REVERSE 0x00001502 +#define NV11_3D_COLOR_LOGIC_OP_OP_COPY 0x00001503 +#define NV11_3D_COLOR_LOGIC_OP_OP_AND_INVERTED 0x00001504 +#define NV11_3D_COLOR_LOGIC_OP_OP_NOOP 0x00001505 +#define NV11_3D_COLOR_LOGIC_OP_OP_XOR 0x00001506 +#define NV11_3D_COLOR_LOGIC_OP_OP_OR 0x00001507 +#define NV11_3D_COLOR_LOGIC_OP_OP_NOR 0x00001508 +#define NV11_3D_COLOR_LOGIC_OP_OP_EQUIV 0x00001509 +#define NV11_3D_COLOR_LOGIC_OP_OP_INVERT 0x0000150a +#define NV11_3D_COLOR_LOGIC_OP_OP_OR_REVERSE 0x0000150b +#define NV11_3D_COLOR_LOGIC_OP_OP_COPY_INVERTED 0x0000150c +#define NV11_3D_COLOR_LOGIC_OP_OP_OR_INVERTED 0x0000150d +#define NV11_3D_COLOR_LOGIC_OP_OP_NAND 0x0000150e +#define NV11_3D_COLOR_LOGIC_OP_OP_SET 0x0000150f + + +#endif /* NV10_3D_XML */ diff --git a/src/mesa/drivers/dri/nouveau/nv10_context.c b/src/mesa/drivers/dri/nouveau/nv10_context.c index fdcb43b771..8074b4bb47 100644 --- a/src/mesa/drivers/dri/nouveau/nv10_context.c +++ b/src/mesa/drivers/dri/nouveau/nv10_context.c @@ -24,11 +24,13 @@ * */ +#include "main/state.h" #include "nouveau_driver.h" #include "nouveau_context.h" #include "nouveau_fbo.h" #include "nouveau_util.h" -#include "nouveau_class.h" +#include "nv_object.xml.h" +#include "nv10_3d.xml.h" #include "nv04_driver.h" #include "nv10_driver.h" @@ -156,9 +158,9 @@ nv17_zclear(struct gl_context *ctx, GLbitfield *buffers) nfb->base._DepthBuffer->Wrapped)->surface; /* Clear the hierarchical depth buffer */ - BEGIN_RING(chan, celsius, NV17TCL_LMA_DEPTH_FILL_VALUE, 1); + BEGIN_RING(chan, celsius, NV17_3D_HIERZ_FILL_VALUE, 1); OUT_RING(chan, pack_zs_f(s->format, ctx->Depth.Clear, 0)); - BEGIN_RING(chan, celsius, NV17TCL_LMA_DEPTH_BUFFER_CLEAR, 1); + BEGIN_RING(chan, celsius, NV17_3D_HIERZ_BUFFER_CLEAR, 1); OUT_RING(chan, 1); /* Mark the depth buffer as cleared */ @@ -184,6 +186,9 @@ nv10_clear(struct gl_context *ctx, GLbitfield buffers) nv17_zclear(ctx, &buffers); else nv10_zclear(ctx, &buffers); + + /* Emit the zclear state if it's dirty */ + _mesa_update_state(ctx); } nouveau_clear(ctx, buffers); @@ -197,33 +202,33 @@ nv10_hwctx_init(struct gl_context *ctx) struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw; int i; - BEGIN_RING(chan, celsius, NV10TCL_DMA_NOTIFY, 1); + BEGIN_RING(chan, celsius, NV10_3D_DMA_NOTIFY, 1); OUT_RING(chan, hw->ntfy->handle); - BEGIN_RING(chan, celsius, NV10TCL_DMA_IN_MEMORY0, 3); + 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, NV10TCL_DMA_IN_MEMORY2, 2); + 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, NV10TCL_NOP, 1); + BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_RT_HORIZ, 2); + BEGIN_RING(chan, celsius, NV10_3D_RT_HORIZ, 2); OUT_RING(chan, 0); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_VIEWPORT_CLIP_HORIZ(0), 1); + BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_CLIP_HORIZ(0), 1); OUT_RING(chan, 0x7ff << 16 | 0x800); - BEGIN_RING(chan, celsius, NV10TCL_VIEWPORT_CLIP_VERT(0), 1); + 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, NV10TCL_VIEWPORT_CLIP_HORIZ(i), 1); + BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_CLIP_HORIZ(i), 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_VIEWPORT_CLIP_VERT(i), 1); + BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_CLIP_VERT(i), 1); OUT_RING(chan, 0); } @@ -232,18 +237,18 @@ nv10_hwctx_init(struct gl_context *ctx) BEGIN_RING(chan, celsius, 0x3f4, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_NOP, 1); + BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1); OUT_RING(chan, 0); if (context_chipset(ctx) >= 0x17) { - BEGIN_RING(chan, celsius, NV17TCL_DMA_IN_MEMORY4, 2); + 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, NV17TCL_COLOR_MASK_ENABLE, 1); + BEGIN_RING(chan, celsius, NV17_3D_COLOR_MASK_ENABLE, 1); OUT_RING(chan, 1); } @@ -253,41 +258,41 @@ nv10_hwctx_init(struct gl_context *ctx) OUT_RING(chan, 1); OUT_RING(chan, 2); - BEGIN_RING(chan, celsius, NV10TCL_NOP, 1); + BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1); OUT_RING(chan, 0); } - BEGIN_RING(chan, celsius, NV10TCL_NOP, 1); + BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1); OUT_RING(chan, 0); /* Set state */ - BEGIN_RING(chan, celsius, NV10TCL_FOG_ENABLE, 1); + BEGIN_RING(chan, celsius, NV10_3D_FOG_ENABLE, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_ALPHA_FUNC_ENABLE, 1); + BEGIN_RING(chan, celsius, NV10_3D_ALPHA_FUNC_ENABLE, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_ALPHA_FUNC_FUNC, 2); + BEGIN_RING(chan, celsius, NV10_3D_ALPHA_FUNC_FUNC, 2); OUT_RING(chan, 0x207); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_TX_ENABLE(0), 2); + BEGIN_RING(chan, celsius, NV10_3D_TEX_ENABLE(0), 2); OUT_RING(chan, 0); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_BLEND_FUNC_ENABLE, 1); + BEGIN_RING(chan, celsius, NV10_3D_BLEND_FUNC_ENABLE, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_DITHER_ENABLE, 2); + BEGIN_RING(chan, celsius, NV10_3D_DITHER_ENABLE, 2); OUT_RING(chan, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_LINE_SMOOTH_ENABLE, 1); + BEGIN_RING(chan, celsius, NV10_3D_LINE_SMOOTH_ENABLE, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_VERTEX_WEIGHT_ENABLE, 2); + BEGIN_RING(chan, celsius, NV10_3D_VERTEX_WEIGHT_ENABLE, 2); OUT_RING(chan, 0); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_BLEND_FUNC_SRC, 4); + 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, NV10TCL_STENCIL_MASK, 8); + BEGIN_RING(chan, celsius, NV10_3D_STENCIL_MASK, 8); OUT_RING(chan, 0xff); OUT_RING(chan, 0x207); OUT_RING(chan, 0); @@ -296,105 +301,105 @@ nv10_hwctx_init(struct gl_context *ctx) OUT_RING(chan, 0x1e00); OUT_RING(chan, 0x1e00); OUT_RING(chan, 0x1d01); - BEGIN_RING(chan, celsius, NV10TCL_NORMALIZE_ENABLE, 1); + BEGIN_RING(chan, celsius, NV10_3D_NORMALIZE_ENABLE, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_FOG_ENABLE, 2); + BEGIN_RING(chan, celsius, NV10_3D_FOG_ENABLE, 2); OUT_RING(chan, 0); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_LIGHT_MODEL, 1); + BEGIN_RING(chan, celsius, NV10_3D_LIGHT_MODEL, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_SEPARATE_SPECULAR_ENABLE, 1); + BEGIN_RING(chan, celsius, NV10_3D_SEPARATE_SPECULAR_ENABLE, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_ENABLED_LIGHTS, 1); + BEGIN_RING(chan, celsius, NV10_3D_ENABLED_LIGHTS, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_POLYGON_OFFSET_POINT_ENABLE, 3); + 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, NV10TCL_DEPTH_FUNC, 1); + BEGIN_RING(chan, celsius, NV10_3D_DEPTH_FUNC, 1); OUT_RING(chan, 0x201); - BEGIN_RING(chan, celsius, NV10TCL_DEPTH_WRITE_ENABLE, 1); + BEGIN_RING(chan, celsius, NV10_3D_DEPTH_WRITE_ENABLE, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_DEPTH_TEST_ENABLE, 1); + BEGIN_RING(chan, celsius, NV10_3D_DEPTH_TEST_ENABLE, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_POLYGON_OFFSET_FACTOR, 2); + BEGIN_RING(chan, celsius, NV10_3D_POLYGON_OFFSET_FACTOR, 2); OUT_RING(chan, 0); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_POINT_SIZE, 1); + BEGIN_RING(chan, celsius, NV10_3D_POINT_SIZE, 1); OUT_RING(chan, 8); - BEGIN_RING(chan, celsius, NV10TCL_POINT_PARAMETERS_ENABLE, 2); + BEGIN_RING(chan, celsius, NV10_3D_POINT_PARAMETERS_ENABLE, 2); OUT_RING(chan, 0); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_LINE_WIDTH, 1); + BEGIN_RING(chan, celsius, NV10_3D_LINE_WIDTH, 1); OUT_RING(chan, 8); - BEGIN_RING(chan, celsius, NV10TCL_LINE_SMOOTH_ENABLE, 1); + BEGIN_RING(chan, celsius, NV10_3D_LINE_SMOOTH_ENABLE, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_POLYGON_MODE_FRONT, 2); + BEGIN_RING(chan, celsius, NV10_3D_POLYGON_MODE_FRONT, 2); OUT_RING(chan, 0x1b02); OUT_RING(chan, 0x1b02); - BEGIN_RING(chan, celsius, NV10TCL_CULL_FACE, 2); + BEGIN_RING(chan, celsius, NV10_3D_CULL_FACE, 2); OUT_RING(chan, 0x405); OUT_RING(chan, 0x901); - BEGIN_RING(chan, celsius, NV10TCL_POLYGON_SMOOTH_ENABLE, 1); + BEGIN_RING(chan, celsius, NV10_3D_POLYGON_SMOOTH_ENABLE, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_CULL_FACE_ENABLE, 1); + BEGIN_RING(chan, celsius, NV10_3D_CULL_FACE_ENABLE, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_TX_GEN_MODE_S(0), 8); + 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, NV10TCL_TX_MATRIX_ENABLE(0), 2); + BEGIN_RING(chan, celsius, NV10_3D_TEX_MATRIX_ENABLE(0), 2); OUT_RING(chan, 0); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_FOG_EQUATION_CONSTANT, 3); + 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, NV10TCL_NOP, 1); + BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1); OUT_RING(chan, 0); - BEGIN_RING(chan, celsius, NV10TCL_FOG_MODE, 2); + 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, NV10TCL_VIEW_MATRIX_ENABLE, 1); + BEGIN_RING(chan, celsius, NV10_3D_VIEW_MATRIX_ENABLE, 1); OUT_RING(chan, 6); - BEGIN_RING(chan, celsius, NV10TCL_COLOR_MASK, 1); + BEGIN_RING(chan, celsius, NV10_3D_COLOR_MASK, 1); OUT_RING(chan, 0x01010101); /* Set vertex component */ - BEGIN_RING(chan, celsius, NV10TCL_VERTEX_COL_4F_R, 4); + 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, NV10TCL_VERTEX_COL2_3F_R, 3); + 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, NV10TCL_VERTEX_NOR_3F_X, 3); + 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, NV10TCL_VERTEX_TX0_4F_S, 4); + 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, NV10TCL_VERTEX_TX1_4F_S, 4); + 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, NV10TCL_VERTEX_FOG_1F, 1); + BEGIN_RING(chan, celsius, NV10_3D_VERTEX_FOG_1F, 1); OUT_RINGf(chan, 0.0); - BEGIN_RING(chan, celsius, NV10TCL_EDGEFLAG_ENABLE, 1); + BEGIN_RING(chan, celsius, NV10_3D_EDGEFLAG_ENABLE, 1); OUT_RING(chan, 1); - BEGIN_RING(chan, celsius, NV10TCL_DEPTH_RANGE_NEAR, 2); + BEGIN_RING(chan, celsius, NV10_3D_DEPTH_RANGE_NEAR, 2); OUT_RINGf(chan, 0.0); OUT_RINGf(chan, 16777216.0); @@ -407,7 +412,8 @@ nv10_context_destroy(struct gl_context *ctx) struct nouveau_context *nctx = to_nouveau_context(ctx); nv04_surface_takedown(ctx); - nv10_render_destroy(ctx); + nv10_swtnl_destroy(ctx); + nv10_vbo_destroy(ctx); nouveau_grobj_free(&nctx->hw.eng3d); @@ -451,11 +457,11 @@ nv10_context_create(struct nouveau_screen *screen, const struct gl_config *visua /* 3D engine. */ if (context_chipset(ctx) >= 0x17) - celsius_class = NV17TCL; + celsius_class = NV17_3D; else if (context_chipset(ctx) >= 0x11) - celsius_class = NV11TCL; + celsius_class = NV11_3D; else - celsius_class = NV10TCL; + celsius_class = NV10_3D; ret = nouveau_grobj_alloc(context_chan(ctx), 0xbeef0001, celsius_class, &nctx->hw.eng3d); @@ -463,7 +469,8 @@ nv10_context_create(struct nouveau_screen *screen, const struct gl_config *visua goto fail; nv10_hwctx_init(ctx); - nv10_render_init(ctx); + nv10_vbo_init(ctx); + nv10_swtnl_init(ctx); return ctx; diff --git a/src/mesa/drivers/dri/nouveau/nv10_driver.h b/src/mesa/drivers/dri/nouveau/nv10_driver.h index dec3d64e7d..6fdc464162 100644 --- a/src/mesa/drivers/dri/nouveau/nv10_driver.h +++ b/src/mesa/drivers/dri/nouveau/nv10_driver.h @@ -45,10 +45,16 @@ nv10_transform_depth(struct gl_context *ctx, float z); /* nv10_render.c */ void -nv10_render_init(struct gl_context *ctx); +nv10_vbo_init(struct gl_context *ctx); void -nv10_render_destroy(struct gl_context *ctx); +nv10_vbo_destroy(struct gl_context *ctx); + +void +nv10_swtnl_init(struct gl_context *ctx); + +void +nv10_swtnl_destroy(struct gl_context *ctx); /* nv10_state_fb.c */ void diff --git a/src/mesa/drivers/dri/nouveau/nv10_render.c b/src/mesa/drivers/dri/nouveau/nv10_render.c index a03ace3536..20fb447842 100644 --- a/src/mesa/drivers/dri/nouveau/nv10_render.c +++ b/src/mesa/drivers/dri/nouveau/nv10_render.c @@ -26,50 +26,50 @@ #include "nouveau_driver.h" #include "nouveau_context.h" -#include "nouveau_class.h" +#include "nv10_3d.xml.h" #include "nv10_driver.h" #define NUM_VERTEX_ATTRS 8 static void -nv10_emit_material(struct gl_context *ctx, struct nouveau_array_state *a, +nv10_emit_material(struct gl_context *ctx, struct nouveau_array *a, const void *v); /* Vertex attribute format. */ static struct nouveau_attr_info nv10_vertex_attrs[VERT_ATTRIB_MAX] = { [VERT_ATTRIB_POS] = { .vbo_index = 0, - .imm_method = NV10TCL_VERTEX_POS_4F_X, + .imm_method = NV10_3D_VERTEX_POS_4F_X, .imm_fields = 4, }, [VERT_ATTRIB_COLOR0] = { .vbo_index = 1, - .imm_method = NV10TCL_VERTEX_COL_4F_R, + .imm_method = NV10_3D_VERTEX_COL_4F_R, .imm_fields = 4, }, [VERT_ATTRIB_COLOR1] = { .vbo_index = 2, - .imm_method = NV10TCL_VERTEX_COL2_3F_R, + .imm_method = NV10_3D_VERTEX_COL2_3F_R, .imm_fields = 3, }, [VERT_ATTRIB_TEX0] = { .vbo_index = 3, - .imm_method = NV10TCL_VERTEX_TX0_4F_S, + .imm_method = NV10_3D_VERTEX_TX0_4F_S, .imm_fields = 4, }, [VERT_ATTRIB_TEX1] = { .vbo_index = 4, - .imm_method = NV10TCL_VERTEX_TX1_4F_S, + .imm_method = NV10_3D_VERTEX_TX1_4F_S, .imm_fields = 4, }, [VERT_ATTRIB_NORMAL] = { .vbo_index = 5, - .imm_method = NV10TCL_VERTEX_NOR_3F_X, + .imm_method = NV10_3D_VERTEX_NOR_3F_X, .imm_fields = 3, }, [VERT_ATTRIB_FOG] = { .vbo_index = 7, - .imm_method = NV10TCL_VERTEX_FOG_1F, + .imm_method = NV10_3D_VERTEX_FOG_1F, .imm_fields = 1, }, [VERT_ATTRIB_GENERIC0] = { @@ -94,12 +94,12 @@ get_hw_format(int type) { switch (type) { case GL_FLOAT: - return NV10TCL_VTXFMT_TYPE_FLOAT; + return NV10_3D_VTXBUF_FMT_TYPE_V32_FLOAT; case GL_SHORT: case GL_UNSIGNED_SHORT: - return NV10TCL_VTXFMT_TYPE_SHORT; + return NV10_3D_VTXBUF_FMT_TYPE_V16_SNORM; case GL_UNSIGNED_BYTE: - return NV10TCL_VTXFMT_TYPE_BYTE_RGBA; + return NV10_3D_VTXBUF_FMT_TYPE_B8G8R8A8_UNORM; default: assert(0); } @@ -111,26 +111,24 @@ nv10_render_set_format(struct gl_context *ctx) struct nouveau_render_state *render = to_render_state(ctx); struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - int i, hw_format; - - for (i = 0; i < NUM_VERTEX_ATTRS; i++) { - int attr = render->map[i]; + int i, attr, hw_format; + FOR_EACH_ATTR(render, i, attr) { if (attr >= 0) { - struct nouveau_array_state *a = &render->attrs[attr]; + struct nouveau_array *a = &render->attrs[attr]; hw_format = a->stride << 8 | a->fields << 4 | get_hw_format(a->type); if (attr == VERT_ATTRIB_POS && a->fields == 4) - hw_format |= NV10TCL_VTXFMT_POS_HOMOGENEOUS; + hw_format |= NV10_3D_VTXBUF_FMT_HOMOGENEOUS; } else { /* Unused attribute. */ - hw_format = NV10TCL_VTXFMT_TYPE_FLOAT; + hw_format = NV10_3D_VTXBUF_FMT_TYPE_V32_FLOAT; } - BEGIN_RING(chan, celsius, NV10TCL_VTXFMT(i), 1); + BEGIN_RING(chan, celsius, NV10_3D_VTXBUF_FMT(i), 1); OUT_RING(chan, hw_format); } } @@ -140,55 +138,51 @@ nv10_render_bind_vertices(struct gl_context *ctx) { struct nouveau_render_state *render = to_render_state(ctx); struct nouveau_bo_context *bctx = context_bctx(ctx, VERTEX); - struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - int i; + int i, attr; - for (i = 0; i < NUM_VERTEX_ATTRS; i++) { - int attr = render->map[i]; - - if (attr >= 0) { - struct nouveau_array_state *a = &render->attrs[attr]; + FOR_EACH_BOUND_ATTR(render, i, attr) { + struct nouveau_array *a = &render->attrs[attr]; - nouveau_bo_markl(bctx, celsius, - NV10TCL_VTXBUF_ADDRESS(i), - a->bo, a->offset, - NOUVEAU_BO_GART | NOUVEAU_BO_RD); - } + nouveau_bo_markl(bctx, celsius, + NV10_3D_VTXBUF_OFFSET(i), + a->bo, a->offset, + NOUVEAU_BO_GART | NOUVEAU_BO_RD); } - - BEGIN_RING(chan, celsius, NV10TCL_VERTEX_ARRAY_VALIDATE, 1); - OUT_RING(chan, 0); } /* Vertex array rendering defs. */ #define RENDER_LOCALS(ctx) \ struct nouveau_grobj *celsius = context_eng3d(ctx) +#define BATCH_VALIDATE() \ + BEGIN_RING(chan, celsius, NV10_3D_VTXBUF_VALIDATE, 1); \ + OUT_RING(chan, 0) + #define BATCH_BEGIN(prim) \ - BEGIN_RING(chan, celsius, NV10TCL_VERTEX_BUFFER_BEGIN_END, 1); \ + BEGIN_RING(chan, celsius, NV10_3D_VTXBUF_BEGIN_END, 1); \ OUT_RING(chan, prim) #define BATCH_END() \ - BEGIN_RING(chan, celsius, NV10TCL_VERTEX_BUFFER_BEGIN_END, 1); \ + BEGIN_RING(chan, celsius, NV10_3D_VTXBUF_BEGIN_END, 1); \ OUT_RING(chan, 0) #define MAX_PACKET 0x400 #define MAX_OUT_L 0x100 #define BATCH_PACKET_L(n) \ - BEGIN_RING_NI(chan, celsius, NV10TCL_VERTEX_BUFFER_DRAW_ARRAYS, n) + BEGIN_RING_NI(chan, celsius, NV10_3D_VTXBUF_BATCH, n) #define BATCH_OUT_L(i, n) \ OUT_RING(chan, ((n) - 1) << 24 | (i)) #define MAX_OUT_I16 0x2 #define BATCH_PACKET_I16(n) \ - BEGIN_RING_NI(chan, celsius, NV10TCL_VB_ELEMENT_U16, n) + BEGIN_RING_NI(chan, celsius, NV10_3D_VTXBUF_ELEMENT_U16, n) #define BATCH_OUT_I16(i0, i1) \ OUT_RING(chan, (i1) << 16 | (i0)) #define MAX_OUT_I32 0x1 #define BATCH_PACKET_I32(n) \ - BEGIN_RING_NI(chan, celsius, NV10TCL_VB_ELEMENT_U32, n) + BEGIN_RING_NI(chan, celsius, NV10_3D_VTXBUF_ELEMENT_U32, n) #define BATCH_OUT_I32(i) \ OUT_RING(chan, i) @@ -199,3 +193,5 @@ nv10_render_bind_vertices(struct gl_context *ctx) #define TAG(x) nv10_##x #include "nouveau_render_t.c" +#include "nouveau_vbo_t.c" +#include "nouveau_swtnl_t.c" diff --git a/src/mesa/drivers/dri/nouveau/nv10_state_fb.c b/src/mesa/drivers/dri/nouveau/nv10_state_fb.c index d87fe96b1c..0505547421 100644 --- a/src/mesa/drivers/dri/nouveau/nv10_state_fb.c +++ b/src/mesa/drivers/dri/nouveau/nv10_state_fb.c @@ -27,8 +27,9 @@ #include "nouveau_driver.h" #include "nouveau_context.h" #include "nouveau_fbo.h" -#include "nouveau_class.h" #include "nouveau_util.h" +#include "nv_object.xml.h" +#include "nv10_3d.xml.h" #include "nv10_driver.h" static inline unsigned @@ -36,26 +37,26 @@ get_rt_format(gl_format format) { switch (format) { case MESA_FORMAT_XRGB8888: - return 0x05; + return NV10_3D_RT_FORMAT_COLOR_X8R8G8B8; case MESA_FORMAT_ARGB8888: - return 0x08; + return NV10_3D_RT_FORMAT_COLOR_A8R8G8B8; case MESA_FORMAT_RGB565: - return 0x03; + return NV10_3D_RT_FORMAT_COLOR_R5G6B5; case MESA_FORMAT_Z16: - return 0x10; + return NV10_3D_RT_FORMAT_DEPTH_Z16; case MESA_FORMAT_Z24_S8: - return 0x0; + return NV10_3D_RT_FORMAT_DEPTH_Z24S8; default: assert(0); } } static void -setup_lma_buffer(struct gl_context *ctx) +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, LMA_DEPTH); + 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), @@ -68,20 +69,20 @@ setup_lma_buffer(struct gl_context *ctx) 0, NOUVEAU_BO_TILE_ZETA, &nfb->hierz.bo); } - nouveau_bo_markl(bctx, celsius, NV17TCL_LMA_DEPTH_BUFFER_OFFSET, + 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, NV17TCL_LMA_DEPTH_WINDOW_X, 4); + 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, NV17TCL_LMA_DEPTH_BUFFER_PITCH, 1); + BEGIN_RING(chan, celsius, NV17_3D_HIERZ_PITCH, 1); OUT_RING(chan, pitch); - BEGIN_RING(chan, celsius, NV17TCL_LMA_DEPTH_ENABLE, 1); + BEGIN_RING(chan, celsius, NV17_3D_HIERZ_ENABLE, 1); OUT_RING(chan, 1); } @@ -93,7 +94,7 @@ nv10_emit_framebuffer(struct gl_context *ctx, int emit) struct nouveau_bo_context *bctx = context_bctx(ctx, FRAMEBUFFER); struct gl_framebuffer *fb = ctx->DrawBuffer; struct nouveau_surface *s; - unsigned rt_format = NV10TCL_RT_FORMAT_TYPE_LINEAR; + unsigned rt_format = NV10_3D_RT_FORMAT_TYPE_LINEAR; unsigned rt_pitch = 0, zeta_pitch = 0; unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR; @@ -106,7 +107,7 @@ nv10_emit_framebuffer(struct gl_context *ctx, int emit) int i; for (i = 0; i < 6; i++) { - BEGIN_RING(chan, celsius, NV10TCL_NOP, 1); + BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1); OUT_RING(chan, 0); } } @@ -119,7 +120,7 @@ nv10_emit_framebuffer(struct gl_context *ctx, int emit) rt_format |= get_rt_format(s->format); zeta_pitch = rt_pitch = s->pitch; - nouveau_bo_markl(bctx, celsius, NV10TCL_COLOR_OFFSET, + nouveau_bo_markl(bctx, celsius, NV10_3D_COLOR_OFFSET, s->bo, 0, bo_flags); } @@ -131,16 +132,16 @@ nv10_emit_framebuffer(struct gl_context *ctx, int emit) rt_format |= get_rt_format(s->format); zeta_pitch = s->pitch; - nouveau_bo_markl(bctx, celsius, NV10TCL_ZETA_OFFSET, + nouveau_bo_markl(bctx, celsius, NV10_3D_ZETA_OFFSET, s->bo, 0, bo_flags); if (context_chipset(ctx) >= 0x17) { - setup_lma_buffer(ctx); + setup_hierz_buffer(ctx); context_dirty(ctx, ZCLEAR); } } - BEGIN_RING(chan, celsius, NV10TCL_RT_FORMAT, 2); + BEGIN_RING(chan, celsius, NV10_3D_RT_FORMAT, 2); OUT_RING(chan, rt_format); OUT_RING(chan, zeta_pitch << 16 | rt_pitch); @@ -162,7 +163,7 @@ nv10_emit_scissor(struct gl_context *ctx, int emit) get_scissors(ctx->DrawBuffer, &x, &y, &w, &h); - BEGIN_RING(chan, celsius, NV10TCL_RT_HORIZ, 2); + BEGIN_RING(chan, celsius, NV10_3D_RT_HORIZ, 2); OUT_RING(chan, w << 16 | x); OUT_RING(chan, h << 16 | y); } @@ -182,12 +183,12 @@ nv10_emit_viewport(struct gl_context *ctx, int emit) if (nv10_use_viewport_zclear(ctx)) a[2] = nv10_transform_depth(ctx, (vp->Far + vp->Near) / 2); - BEGIN_RING(chan, celsius, NV10TCL_VIEWPORT_TRANSLATE_X, 4); + BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_TRANSLATE_X, 4); OUT_RINGp(chan, a, 4); - BEGIN_RING(chan, celsius, NV10TCL_VIEWPORT_CLIP_HORIZ(0), 1); + BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_CLIP_HORIZ(0), 1); OUT_RING(chan, (fb->Width - 1) << 16 | 0x08000800); - BEGIN_RING(chan, celsius, NV10TCL_VIEWPORT_CLIP_VERT(0), 1); + BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_CLIP_VERT(0), 1); OUT_RING(chan, (fb->Height - 1) << 16 | 0x08000800); context_dirty(ctx, PROJECTION); @@ -203,12 +204,12 @@ nv10_emit_zclear(struct gl_context *ctx, int emit) to_nouveau_framebuffer(ctx->DrawBuffer); if (nfb->hierz.bo) { - BEGIN_RING(chan, celsius, NV17TCL_ZCLEAR_ENABLE, 2); - OUT_RING(chan, nctx->hierz.clear_blocked ? 0 : 1); + 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, NV10TCL_DEPTH_RANGE_NEAR, 2); + 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); diff --git a/src/mesa/drivers/dri/nouveau/nv10_state_frag.c b/src/mesa/drivers/dri/nouveau/nv10_state_frag.c index 5138c36df7..1adc86086c 100644 --- a/src/mesa/drivers/dri/nouveau/nv10_state_frag.c +++ b/src/mesa/drivers/dri/nouveau/nv10_state_frag.c @@ -27,7 +27,7 @@ #include "nouveau_driver.h" #include "nouveau_context.h" #include "nouveau_gldefs.h" -#include "nouveau_class.h" +#include "nv10_3d.xml.h" #include "nouveau_util.h" #include "nv10_driver.h" #include "nv20_driver.h" @@ -41,24 +41,24 @@ #define RC_IN_SHIFT_G 40 #define RC_IN_SOURCE(source) \ - ((uint64_t)NV10TCL_RC_IN_RGB_D_INPUT_##source) + ((uint64_t)NV10_3D_RC_IN_RGB_D_INPUT_##source) #define RC_IN_USAGE(usage) \ - ((uint64_t)NV10TCL_RC_IN_RGB_D_COMPONENT_USAGE_##usage) + ((uint64_t)NV10_3D_RC_IN_RGB_D_COMPONENT_USAGE_##usage) #define RC_IN_MAPPING(mapping) \ - ((uint64_t)NV10TCL_RC_IN_RGB_D_MAPPING_##mapping) + ((uint64_t)NV10_3D_RC_IN_RGB_D_MAPPING_##mapping) -#define RC_OUT_BIAS NV10TCL_RC_OUT_RGB_BIAS_BIAS_BY_NEGATIVE_ONE_HALF -#define RC_OUT_SCALE_1 NV10TCL_RC_OUT_RGB_SCALE_NONE -#define RC_OUT_SCALE_2 NV10TCL_RC_OUT_RGB_SCALE_SCALE_BY_TWO -#define RC_OUT_SCALE_4 NV10TCL_RC_OUT_RGB_SCALE_SCALE_BY_FOUR +#define RC_OUT_BIAS NV10_3D_RC_OUT_RGB_BIAS_BIAS_BY_NEGATIVE_ONE_HALF +#define RC_OUT_SCALE_1 NV10_3D_RC_OUT_RGB_SCALE_NONE +#define RC_OUT_SCALE_2 NV10_3D_RC_OUT_RGB_SCALE_SCALE_BY_TWO +#define RC_OUT_SCALE_4 NV10_3D_RC_OUT_RGB_SCALE_SCALE_BY_FOUR /* Make the combiner do: spare0_i = A_i * B_i */ -#define RC_OUT_AB NV10TCL_RC_OUT_RGB_AB_OUTPUT_SPARE0 +#define RC_OUT_AB NV10_3D_RC_OUT_RGB_AB_OUTPUT_SPARE0 /* spare0_i = dot3(A, B) */ -#define RC_OUT_DOT_AB (NV10TCL_RC_OUT_RGB_AB_OUTPUT_SPARE0 | \ - NV10TCL_RC_OUT_RGB_AB_DOT_PRODUCT) +#define RC_OUT_DOT_AB (NV10_3D_RC_OUT_RGB_AB_OUTPUT_SPARE0 | \ + NV10_3D_RC_OUT_RGB_AB_DOT_PRODUCT) /* spare0_i = A_i * B_i + C_i * D_i */ -#define RC_OUT_SUM NV10TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE0 +#define RC_OUT_SUM NV10_3D_RC_OUT_RGB_SUM_OUTPUT_SPARE0 struct combiner_state { struct gl_context *ctx; @@ -383,15 +383,15 @@ nv10_emit_tex_env(struct gl_context *ctx, int emit) c_out |= 0x3 << 27; } - BEGIN_RING(chan, celsius, NV10TCL_RC_IN_ALPHA(i), 1); + BEGIN_RING(chan, celsius, NV10_3D_RC_IN_ALPHA(i), 1); OUT_RING(chan, a_in); - BEGIN_RING(chan, celsius, NV10TCL_RC_IN_RGB(i), 1); + BEGIN_RING(chan, celsius, NV10_3D_RC_IN_RGB(i), 1); OUT_RING(chan, c_in); - BEGIN_RING(chan, celsius, NV10TCL_RC_COLOR(i), 1); + BEGIN_RING(chan, celsius, NV10_3D_RC_COLOR(i), 1); OUT_RING(chan, k); - BEGIN_RING(chan, celsius, NV10TCL_RC_OUT_ALPHA(i), 1); + BEGIN_RING(chan, celsius, NV10_3D_RC_OUT_ALPHA(i), 1); OUT_RING(chan, a_out); - BEGIN_RING(chan, celsius, NV10TCL_RC_OUT_RGB(i), 1); + BEGIN_RING(chan, celsius, NV10_3D_RC_OUT_RGB(i), 1); OUT_RING(chan, c_out); context_dirty(ctx, FRAG); @@ -407,7 +407,7 @@ nv10_emit_frag(struct gl_context *ctx, int emit) nv10_get_final_combiner(ctx, &in, &n); - BEGIN_RING(chan, celsius, NV10TCL_RC_FINAL0, 2); + BEGIN_RING(chan, celsius, NV10_3D_RC_FINAL0, 2); OUT_RING(chan, in); OUT_RING(chan, in >> 32); } diff --git a/src/mesa/drivers/dri/nouveau/nv10_state_polygon.c b/src/mesa/drivers/dri/nouveau/nv10_state_polygon.c index 4e49b0278c..3f80790483 100644 --- a/src/mesa/drivers/dri/nouveau/nv10_state_polygon.c +++ b/src/mesa/drivers/dri/nouveau/nv10_state_polygon.c @@ -27,7 +27,8 @@ #include "nouveau_driver.h" #include "nouveau_context.h" #include "nouveau_gldefs.h" -#include "nouveau_class.h" +#include "nouveau_util.h" +#include "nv10_3d.xml.h" #include "nv10_driver.h" void @@ -37,13 +38,13 @@ nv10_emit_cull_face(struct gl_context *ctx, int emit) struct nouveau_grobj *celsius = context_eng3d(ctx); GLenum mode = ctx->Polygon.CullFaceMode; - BEGIN_RING(chan, celsius, NV10TCL_CULL_FACE_ENABLE, 1); - OUT_RING(chan, ctx->Polygon.CullFlag ? 1 : 0); + BEGIN_RING(chan, celsius, NV10_3D_CULL_FACE_ENABLE, 1); + OUT_RINGb(chan, ctx->Polygon.CullFlag); - BEGIN_RING(chan, celsius, NV10TCL_CULL_FACE, 1); - OUT_RING(chan, (mode == GL_FRONT ? NV10TCL_CULL_FACE_FRONT : - mode == GL_BACK ? NV10TCL_CULL_FACE_BACK : - NV10TCL_CULL_FACE_FRONT_AND_BACK)); + BEGIN_RING(chan, celsius, NV10_3D_CULL_FACE, 1); + OUT_RING(chan, (mode == GL_FRONT ? NV10_3D_CULL_FACE_FRONT : + mode == GL_BACK ? NV10_3D_CULL_FACE_BACK : + NV10_3D_CULL_FACE_FRONT_AND_BACK)); } void @@ -52,9 +53,9 @@ nv10_emit_front_face(struct gl_context *ctx, int emit) struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - BEGIN_RING(chan, celsius, NV10TCL_FRONT_FACE, 1); + BEGIN_RING(chan, celsius, NV10_3D_FRONT_FACE, 1); OUT_RING(chan, ctx->Polygon.FrontFace == GL_CW ? - NV10TCL_FRONT_FACE_CW : NV10TCL_FRONT_FACE_CCW); + NV10_3D_FRONT_FACE_CW : NV10_3D_FRONT_FACE_CCW); } void @@ -65,11 +66,11 @@ nv10_emit_line_mode(struct gl_context *ctx, int emit) GLboolean smooth = ctx->Line.SmoothFlag && ctx->Hint.LineSmooth == GL_NICEST; - BEGIN_RING(chan, celsius, NV10TCL_LINE_WIDTH, 1); + BEGIN_RING(chan, celsius, NV10_3D_LINE_WIDTH, 1); OUT_RING(chan, MAX2(smooth ? 0 : 1, ctx->Line.Width) * 8); - BEGIN_RING(chan, celsius, NV10TCL_LINE_SMOOTH_ENABLE, 1); - OUT_RING(chan, smooth ? 1 : 0); + BEGIN_RING(chan, celsius, NV10_3D_LINE_SMOOTH_ENABLE, 1); + OUT_RINGb(chan, smooth); } void @@ -83,11 +84,11 @@ nv10_emit_point_mode(struct gl_context *ctx, int emit) struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - BEGIN_RING(chan, celsius, NV10TCL_POINT_SIZE, 1); + BEGIN_RING(chan, celsius, NV10_3D_POINT_SIZE, 1); OUT_RING(chan, (uint32_t)(ctx->Point.Size * 8)); - BEGIN_RING(chan, celsius, NV10TCL_POINT_SMOOTH_ENABLE, 1); - OUT_RING(chan, ctx->Point.SmoothFlag ? 1 : 0); + BEGIN_RING(chan, celsius, NV10_3D_POINT_SMOOTH_ENABLE, 1); + OUT_RINGb(chan, ctx->Point.SmoothFlag); } void @@ -96,12 +97,12 @@ nv10_emit_polygon_mode(struct gl_context *ctx, int emit) struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - BEGIN_RING(chan, celsius, NV10TCL_POLYGON_MODE_FRONT, 2); + BEGIN_RING(chan, celsius, NV10_3D_POLYGON_MODE_FRONT, 2); OUT_RING(chan, nvgl_polygon_mode(ctx->Polygon.FrontMode)); OUT_RING(chan, nvgl_polygon_mode(ctx->Polygon.BackMode)); - BEGIN_RING(chan, celsius, NV10TCL_POLYGON_SMOOTH_ENABLE, 1); - OUT_RING(chan, ctx->Polygon.SmoothFlag ? 1 : 0); + BEGIN_RING(chan, celsius, NV10_3D_POLYGON_SMOOTH_ENABLE, 1); + OUT_RINGb(chan, ctx->Polygon.SmoothFlag); } void @@ -110,12 +111,12 @@ nv10_emit_polygon_offset(struct gl_context *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, NV10_3D_POLYGON_OFFSET_POINT_ENABLE, 3); + OUT_RINGb(chan, ctx->Polygon.OffsetPoint); + OUT_RINGb(chan, ctx->Polygon.OffsetLine); + OUT_RINGb(chan, ctx->Polygon.OffsetFill); - BEGIN_RING(chan, celsius, NV10TCL_POLYGON_OFFSET_FACTOR, 2); + BEGIN_RING(chan, celsius, NV10_3D_POLYGON_OFFSET_FACTOR, 2); OUT_RINGf(chan, ctx->Polygon.OffsetFactor); OUT_RINGf(chan, ctx->Polygon.OffsetUnits); } diff --git a/src/mesa/drivers/dri/nouveau/nv10_state_raster.c b/src/mesa/drivers/dri/nouveau/nv10_state_raster.c index 99609844a1..bb1084ed11 100644 --- a/src/mesa/drivers/dri/nouveau/nv10_state_raster.c +++ b/src/mesa/drivers/dri/nouveau/nv10_state_raster.c @@ -27,7 +27,8 @@ #include "nouveau_driver.h" #include "nouveau_context.h" #include "nouveau_gldefs.h" -#include "nouveau_class.h" +#include "nouveau_util.h" +#include "nv10_3d.xml.h" #include "nv10_driver.h" void @@ -36,10 +37,10 @@ nv10_emit_alpha_func(struct gl_context *ctx, int emit) struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - BEGIN_RING(chan, celsius, NV10TCL_ALPHA_FUNC_ENABLE, 1); - OUT_RING(chan, ctx->Color.AlphaEnabled ? 1 : 0); + BEGIN_RING(chan, celsius, NV10_3D_ALPHA_FUNC_ENABLE, 1); + OUT_RINGb(chan, ctx->Color.AlphaEnabled); - BEGIN_RING(chan, celsius, NV10TCL_ALPHA_FUNC_FUNC, 2); + BEGIN_RING(chan, celsius, NV10_3D_ALPHA_FUNC_FUNC, 2); OUT_RING(chan, nvgl_comparison_op(ctx->Color.AlphaFunc)); OUT_RING(chan, FLOAT_TO_UBYTE(ctx->Color.AlphaRef)); } @@ -50,7 +51,7 @@ nv10_emit_blend_color(struct gl_context *ctx, int emit) struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - BEGIN_RING(chan, celsius, NV10TCL_BLEND_COLOR, 1); + BEGIN_RING(chan, celsius, NV10_3D_BLEND_COLOR, 1); OUT_RING(chan, FLOAT_TO_UBYTE(ctx->Color.BlendColor[3]) << 24 | FLOAT_TO_UBYTE(ctx->Color.BlendColor[0]) << 16 | FLOAT_TO_UBYTE(ctx->Color.BlendColor[1]) << 8 | @@ -63,10 +64,10 @@ nv10_emit_blend_equation(struct gl_context *ctx, int emit) struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - BEGIN_RING(chan, celsius, NV10TCL_BLEND_FUNC_ENABLE, 1); - OUT_RING(chan, ctx->Color.BlendEnabled ? 1 : 0); + BEGIN_RING(chan, celsius, NV10_3D_BLEND_FUNC_ENABLE, 1); + OUT_RINGb(chan, ctx->Color.BlendEnabled); - BEGIN_RING(chan, celsius, NV10TCL_BLEND_EQUATION, 1); + BEGIN_RING(chan, celsius, NV10_3D_BLEND_EQUATION, 1); OUT_RING(chan, nvgl_blend_eqn(ctx->Color.BlendEquationRGB)); } @@ -76,7 +77,7 @@ nv10_emit_blend_func(struct gl_context *ctx, int emit) struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - BEGIN_RING(chan, celsius, NV10TCL_BLEND_FUNC_SRC, 2); + BEGIN_RING(chan, celsius, NV10_3D_BLEND_FUNC_SRC, 2); OUT_RING(chan, nvgl_blend_func(ctx->Color.BlendSrcRGB)); OUT_RING(chan, nvgl_blend_func(ctx->Color.BlendDstRGB)); } @@ -87,7 +88,7 @@ nv10_emit_color_mask(struct gl_context *ctx, int emit) struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - BEGIN_RING(chan, celsius, NV10TCL_COLOR_MASK, 1); + BEGIN_RING(chan, celsius, NV10_3D_COLOR_MASK, 1); OUT_RING(chan, ((ctx->Color.ColorMask[0][3] ? 1 << 24 : 0) | (ctx->Color.ColorMask[0][0] ? 1 << 16 : 0) | (ctx->Color.ColorMask[0][1] ? 1 << 8 : 0) | @@ -100,11 +101,11 @@ nv10_emit_depth(struct gl_context *ctx, int emit) struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - BEGIN_RING(chan, celsius, NV10TCL_DEPTH_TEST_ENABLE, 1); - OUT_RING(chan, ctx->Depth.Test ? 1 : 0); - BEGIN_RING(chan, celsius, NV10TCL_DEPTH_WRITE_ENABLE, 1); - OUT_RING(chan, ctx->Depth.Mask ? 1 : 0); - BEGIN_RING(chan, celsius, NV10TCL_DEPTH_FUNC, 1); + BEGIN_RING(chan, celsius, NV10_3D_DEPTH_TEST_ENABLE, 1); + OUT_RINGb(chan, ctx->Depth.Test); + BEGIN_RING(chan, celsius, NV10_3D_DEPTH_WRITE_ENABLE, 1); + OUT_RINGb(chan, ctx->Depth.Mask); + BEGIN_RING(chan, celsius, NV10_3D_DEPTH_FUNC, 1); OUT_RING(chan, nvgl_comparison_op(ctx->Depth.Func)); } @@ -114,8 +115,8 @@ nv10_emit_dither(struct gl_context *ctx, int emit) struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - BEGIN_RING(chan, celsius, NV10TCL_DITHER_ENABLE, 1); - OUT_RING(chan, ctx->Color.DitherFlag ? 1 : 0); + BEGIN_RING(chan, celsius, NV10_3D_DITHER_ENABLE, 1); + OUT_RINGb(chan, ctx->Color.DitherFlag); } void @@ -127,8 +128,8 @@ nv10_emit_logic_opcode(struct gl_context *ctx, int emit) assert(!ctx->Color.ColorLogicOpEnabled || context_chipset(ctx) >= 0x11); - BEGIN_RING(chan, celsius, NV11TCL_COLOR_LOGIC_OP_ENABLE, 2); - OUT_RING(chan, ctx->Color.ColorLogicOpEnabled ? 1 : 0); + BEGIN_RING(chan, celsius, NV11_3D_COLOR_LOGIC_OP_ENABLE, 2); + OUT_RINGb(chan, ctx->Color.ColorLogicOpEnabled); OUT_RING(chan, nvgl_logicop_func(ctx->Color.LogicOp)); } @@ -138,9 +139,9 @@ nv10_emit_shade_model(struct gl_context *ctx, int emit) struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - BEGIN_RING(chan, celsius, NV10TCL_SHADE_MODEL, 1); + BEGIN_RING(chan, celsius, NV10_3D_SHADE_MODEL, 1); OUT_RING(chan, ctx->Light.ShadeModel == GL_SMOOTH ? - NV10TCL_SHADE_MODEL_SMOOTH : NV10TCL_SHADE_MODEL_FLAT); + NV10_3D_SHADE_MODEL_SMOOTH : NV10_3D_SHADE_MODEL_FLAT); } void @@ -149,10 +150,10 @@ nv10_emit_stencil_func(struct gl_context *ctx, int emit) struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - BEGIN_RING(chan, celsius, NV10TCL_STENCIL_ENABLE, 1); - OUT_RING(chan, ctx->Stencil.Enabled ? 1 : 0); + BEGIN_RING(chan, celsius, NV10_3D_STENCIL_ENABLE, 1); + OUT_RINGb(chan, ctx->Stencil.Enabled); - BEGIN_RING(chan, celsius, NV10TCL_STENCIL_FUNC_FUNC, 3); + BEGIN_RING(chan, celsius, NV10_3D_STENCIL_FUNC_FUNC, 3); OUT_RING(chan, nvgl_comparison_op(ctx->Stencil.Function[0])); OUT_RING(chan, ctx->Stencil.Ref[0]); OUT_RING(chan, ctx->Stencil.ValueMask[0]); @@ -164,7 +165,7 @@ nv10_emit_stencil_mask(struct gl_context *ctx, int emit) struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - BEGIN_RING(chan, celsius, NV10TCL_STENCIL_MASK, 1); + BEGIN_RING(chan, celsius, NV10_3D_STENCIL_MASK, 1); OUT_RING(chan, ctx->Stencil.WriteMask[0]); } @@ -174,7 +175,7 @@ nv10_emit_stencil_op(struct gl_context *ctx, int emit) struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); - BEGIN_RING(chan, celsius, NV10TCL_STENCIL_OP_FAIL, 3); + BEGIN_RING(chan, celsius, NV10_3D_STENCIL_OP_FAIL, 3); OUT_RING(chan, nvgl_stencil_op(ctx->Stencil.FailFunc[0])); OUT_RING(chan, nvgl_stencil_op(ctx->Stencil.ZFailFunc[0])); OUT_RING(chan, nvgl_stencil_op(ctx->Stencil.ZPassFunc[0])); diff --git a/src/mesa/drivers/dri/nouveau/nv10_state_tex.c b/src/mesa/drivers/dri/nouveau/nv10_state_tex.c index 0092ad0c20..fda67b1507 100644 --- a/src/mesa/drivers/dri/nouveau/nv10_state_tex.c +++ b/src/mesa/drivers/dri/nouveau/nv10_state_tex.c @@ -28,14 +28,10 @@ #include "nouveau_context.h" #include "nouveau_gldefs.h" #include "nouveau_texture.h" -#include "nouveau_class.h" +#include "nv10_3d.xml.h" #include "nouveau_util.h" #include "nv10_driver.h" -#define TX_GEN_MODE(i, j) (NV10TCL_TX_GEN_MODE_S(i) + 4 * (j)) -#define TX_GEN_COEFF(i, j) (NV10TCL_TX_GEN_COEFF_S_A(i) + 16 * (j)) -#define TX_MATRIX(i) (NV10TCL_TX0_MATRIX(0) + 64 * (i)) - void nv10_emit_tex_gen(struct gl_context *ctx, int emit) { @@ -53,15 +49,15 @@ nv10_emit_tex_gen(struct gl_context *ctx, int emit) if (k) { BEGIN_RING(chan, celsius, - TX_GEN_COEFF(i, j), 4); + NV10_3D_TEX_GEN_COEFF(i, j), 4); OUT_RINGp(chan, k, 4); } - BEGIN_RING(chan, celsius, TX_GEN_MODE(i, j), 1); + BEGIN_RING(chan, celsius, NV10_3D_TEX_GEN_MODE(i,j), 1); OUT_RING(chan, nvgl_texgen_mode(coord->Mode)); } else { - BEGIN_RING(chan, celsius, TX_GEN_MODE(i, j), 1); + BEGIN_RING(chan, celsius, NV10_3D_TEX_GEN_MODE(i,j), 1); OUT_RING(chan, 0); } } @@ -80,14 +76,14 @@ nv10_emit_tex_mat(struct gl_context *ctx, int emit) if (nctx->fallback == HWTNL && ((ctx->Texture._TexMatEnabled & 1 << i) || ctx->Texture.Unit[i]._GenFlags)) { - BEGIN_RING(chan, celsius, NV10TCL_TX_MATRIX_ENABLE(i), 1); + BEGIN_RING(chan, celsius, NV10_3D_TEX_MATRIX_ENABLE(i), 1); OUT_RING(chan, 1); - BEGIN_RING(chan, celsius, TX_MATRIX(i), 16); + BEGIN_RING(chan, celsius, NV10_3D_TEX_MATRIX(i, 0), 16); OUT_RINGm(chan, ctx->TextureMatrixStack[i].Top->m); } else { - BEGIN_RING(chan, celsius, NV10TCL_TX_MATRIX_ENABLE(i), 1); + BEGIN_RING(chan, celsius, NV10_3D_TEX_MATRIX_ENABLE(i), 1); OUT_RING(chan, 0); } } @@ -97,29 +93,29 @@ get_tex_format_pot(struct gl_texture_image *ti) { switch (ti->TexFormat) { case MESA_FORMAT_ARGB8888: - return NV10TCL_TX_FORMAT_FORMAT_A8R8G8B8; + return NV10_3D_TEX_FORMAT_FORMAT_A8R8G8B8; case MESA_FORMAT_XRGB8888: - return NV10TCL_TX_FORMAT_FORMAT_X8R8G8B8; + return NV10_3D_TEX_FORMAT_FORMAT_X8R8G8B8; case MESA_FORMAT_ARGB1555: - return NV10TCL_TX_FORMAT_FORMAT_A1R5G5B5; + return NV10_3D_TEX_FORMAT_FORMAT_A1R5G5B5; case MESA_FORMAT_ARGB4444: - return NV10TCL_TX_FORMAT_FORMAT_A4R4G4B4; + return NV10_3D_TEX_FORMAT_FORMAT_A4R4G4B4; case MESA_FORMAT_RGB565: - return NV10TCL_TX_FORMAT_FORMAT_R5G6B5; + return NV10_3D_TEX_FORMAT_FORMAT_R5G6B5; case MESA_FORMAT_A8: case MESA_FORMAT_I8: - return NV10TCL_TX_FORMAT_FORMAT_A8; + return NV10_3D_TEX_FORMAT_FORMAT_I8; case MESA_FORMAT_L8: - return NV10TCL_TX_FORMAT_FORMAT_L8; + return NV10_3D_TEX_FORMAT_FORMAT_L8; case MESA_FORMAT_CI8: - return NV10TCL_TX_FORMAT_FORMAT_INDEX8; + return NV10_3D_TEX_FORMAT_FORMAT_INDEX8; default: assert(0); @@ -131,19 +127,19 @@ get_tex_format_rect(struct gl_texture_image *ti) { switch (ti->TexFormat) { case MESA_FORMAT_ARGB1555: - return NV10TCL_TX_FORMAT_FORMAT_A1R5G5B5_RECT; + return NV10_3D_TEX_FORMAT_FORMAT_A1R5G5B5_RECT; case MESA_FORMAT_RGB565: - return NV10TCL_TX_FORMAT_FORMAT_R5G6B5_RECT; + return NV10_3D_TEX_FORMAT_FORMAT_R5G6B5_RECT; case MESA_FORMAT_ARGB8888: case MESA_FORMAT_XRGB8888: - return NV10TCL_TX_FORMAT_FORMAT_A8R8G8B8_RECT; + return NV10_3D_TEX_FORMAT_FORMAT_A8R8G8B8_RECT; case MESA_FORMAT_A8: case MESA_FORMAT_L8: case MESA_FORMAT_I8: - return NV10TCL_TX_FORMAT_FORMAT_A8_RECT; + return NV10_3D_TEX_FORMAT_FORMAT_I8_RECT; default: assert(0); @@ -164,7 +160,7 @@ nv10_emit_tex_obj(struct gl_context *ctx, int emit) uint32_t tx_format, tx_filter, tx_enable; if (!ctx->Texture.Unit[i]._ReallyEnabled) { - BEGIN_RING(chan, celsius, NV10TCL_TX_ENABLE(i), 1); + BEGIN_RING(chan, celsius, NV10_3D_TEX_ENABLE(i), 1); OUT_RING(chan, 0); return; } @@ -186,13 +182,13 @@ nv10_emit_tex_obj(struct gl_context *ctx, int emit) tx_filter = nvgl_filter_mode(t->MagFilter) << 28 | nvgl_filter_mode(t->MinFilter) << 24; - tx_enable = NV10TCL_TX_ENABLE_ENABLE + tx_enable = NV10_3D_TEX_ENABLE_ENABLE | log2i(t->MaxAnisotropy) << 4; if (t->Target == GL_TEXTURE_RECTANGLE) { - BEGIN_RING(chan, celsius, NV10TCL_TX_NPOT_PITCH(i), 1); + BEGIN_RING(chan, celsius, NV10_3D_TEX_NPOT_PITCH(i), 1); OUT_RING(chan, s->pitch << 16); - BEGIN_RING(chan, celsius, NV10TCL_TX_NPOT_SIZE(i), 1); + BEGIN_RING(chan, celsius, NV10_3D_TEX_NPOT_SIZE(i), 1); OUT_RING(chan, align(s->width, 2) << 16 | s->height); tx_format |= get_tex_format_rect(ti); @@ -211,26 +207,26 @@ nv10_emit_tex_obj(struct gl_context *ctx, int emit) lod_min = CLAMP(lod_min, 0, 15); lod_bias = CLAMP(lod_bias, 0, 15); - tx_format |= NV10TCL_TX_FORMAT_MIPMAP; + tx_format |= NV10_3D_TEX_FORMAT_MIPMAP; tx_filter |= lod_bias << 8; tx_enable |= lod_min << 26 | lod_max << 14; } /* Write it to the hardware. */ - nouveau_bo_mark(bctx, celsius, NV10TCL_TX_FORMAT(i), + nouveau_bo_mark(bctx, celsius, NV10_3D_TEX_FORMAT(i), s->bo, tx_format, 0, - NV10TCL_TX_FORMAT_DMA0, - NV10TCL_TX_FORMAT_DMA1, + NV10_3D_TEX_FORMAT_DMA0, + NV10_3D_TEX_FORMAT_DMA1, bo_flags | NOUVEAU_BO_OR); - nouveau_bo_markl(bctx, celsius, NV10TCL_TX_OFFSET(i), + nouveau_bo_markl(bctx, celsius, NV10_3D_TEX_OFFSET(i), s->bo, s->offset, bo_flags); - BEGIN_RING(chan, celsius, NV10TCL_TX_FILTER(i), 1); + BEGIN_RING(chan, celsius, NV10_3D_TEX_FILTER(i), 1); OUT_RING(chan, tx_filter); - BEGIN_RING(chan, celsius, NV10TCL_TX_ENABLE(i), 1); + BEGIN_RING(chan, celsius, NV10_3D_TEX_ENABLE(i), 1); OUT_RING(chan, tx_enable); } diff --git a/src/mesa/drivers/dri/nouveau/nv10_state_tnl.c b/src/mesa/drivers/dri/nouveau/nv10_state_tnl.c index 175abfca5c..e8bd12e6e0 100644 --- a/src/mesa/drivers/dri/nouveau/nv10_state_tnl.c +++ b/src/mesa/drivers/dri/nouveau/nv10_state_tnl.c @@ -28,7 +28,7 @@ #include "nouveau_context.h" #include "nouveau_gldefs.h" #include "nouveau_util.h" -#include "nouveau_class.h" +#include "nv10_3d.xml.h" #include "nv10_driver.h" void @@ -42,13 +42,13 @@ get_material_bitmask(unsigned m) unsigned ret = 0; if (m & MAT_BIT_FRONT_EMISSION) - ret |= NV10TCL_COLOR_MATERIAL_EMISSION; + ret |= NV10_3D_COLOR_MATERIAL_EMISSION; if (m & MAT_BIT_FRONT_AMBIENT) - ret |= NV10TCL_COLOR_MATERIAL_AMBIENT; + ret |= NV10_3D_COLOR_MATERIAL_AMBIENT; if (m & MAT_BIT_FRONT_DIFFUSE) - ret |= NV10TCL_COLOR_MATERIAL_DIFFUSE; + ret |= NV10_3D_COLOR_MATERIAL_DIFFUSE; if (m & MAT_BIT_FRONT_SPECULAR) - ret |= NV10TCL_COLOR_MATERIAL_SPECULAR; + ret |= NV10_3D_COLOR_MATERIAL_SPECULAR; return ret; } @@ -60,7 +60,7 @@ nv10_emit_color_material(struct gl_context *ctx, int emit) struct nouveau_grobj *celsius = context_eng3d(ctx); unsigned mask = get_material_bitmask(ctx->Light.ColorMaterialBitmask); - BEGIN_RING(chan, celsius, NV10TCL_COLOR_MATERIAL, 1); + BEGIN_RING(chan, celsius, NV10_3D_COLOR_MATERIAL, 1); OUT_RING(chan, ctx->Light.ColorMaterialEnabled ? mask : 0); } @@ -69,11 +69,11 @@ get_fog_mode(unsigned mode) { switch (mode) { case GL_LINEAR: - return NV10TCL_FOG_MODE_LINEAR; + return NV10_3D_FOG_MODE_LINEAR; case GL_EXP: - return NV10TCL_FOG_MODE_EXP; + return NV10_3D_FOG_MODE_EXP; case GL_EXP2: - return NV10TCL_FOG_MODE_EXP2; + return NV10_3D_FOG_MODE_EXP2; default: assert(0); } @@ -84,9 +84,9 @@ get_fog_source(unsigned source) { switch (source) { case GL_FOG_COORDINATE_EXT: - return NV10TCL_FOG_COORD_FOG; + return NV10_3D_FOG_COORD_FOG; case GL_FRAGMENT_DEPTH_EXT: - return NV10TCL_FOG_COORD_DIST_ORTHOGONAL_ABS; + return NV10_3D_FOG_COORD_DIST_ORTHOGONAL_ABS; default: assert(0); } @@ -133,13 +133,13 @@ nv10_emit_fog(struct gl_context *ctx, int emit) nv10_get_fog_coeff(ctx, k); - BEGIN_RING(chan, celsius, NV10TCL_FOG_MODE, 4); + BEGIN_RING(chan, celsius, NV10_3D_FOG_MODE, 4); OUT_RING(chan, get_fog_mode(f->Mode)); OUT_RING(chan, get_fog_source(source)); - OUT_RING(chan, f->Enabled ? 1 : 0); + OUT_RINGb(chan, f->Enabled); OUT_RING(chan, pack_rgba_f(MESA_FORMAT_RGBA8888_REV, f->Color)); - BEGIN_RING(chan, celsius, NV10TCL_FOG_EQUATION_CONSTANT, 3); + BEGIN_RING(chan, celsius, NV10_3D_FOG_COEFF(0), 3); OUT_RINGp(chan, k, 3); context_dirty(ctx, FRAG); @@ -150,13 +150,13 @@ get_light_mode(struct gl_light *l) { if (l->Enabled) { if (l->_Flags & LIGHT_SPOT) - return NV10TCL_ENABLED_LIGHTS_0_DIRECTIONAL; + return NV10_3D_ENABLED_LIGHTS_0_DIRECTIONAL; else if (l->_Flags & LIGHT_POSITIONAL) - return NV10TCL_ENABLED_LIGHTS_0_POSITIONAL; + return NV10_3D_ENABLED_LIGHTS_0_POSITIONAL; else - return NV10TCL_ENABLED_LIGHTS_0_NONPOSITIONAL; + return NV10_3D_ENABLED_LIGHTS_0_NONPOSITIONAL; } else { - return NV10TCL_ENABLED_LIGHTS_0_DISABLED; + return NV10_3D_ENABLED_LIGHTS_0_DISABLED; } } @@ -170,7 +170,7 @@ nv10_emit_light_enable(struct gl_context *ctx, int emit) int i; if (nctx->fallback != HWTNL) { - BEGIN_RING(chan, celsius, NV10TCL_LIGHTING_ENABLE, 1); + BEGIN_RING(chan, celsius, NV10_3D_LIGHTING_ENABLE, 1); OUT_RING(chan, 0); return; } @@ -178,12 +178,12 @@ nv10_emit_light_enable(struct gl_context *ctx, int emit) for (i = 0; i < MAX_LIGHTS; i++) en_lights |= get_light_mode(&ctx->Light.Light[i]) << 2 * i; - BEGIN_RING(chan, celsius, NV10TCL_ENABLED_LIGHTS, 1); + BEGIN_RING(chan, celsius, NV10_3D_ENABLED_LIGHTS, 1); OUT_RING(chan, en_lights); - BEGIN_RING(chan, celsius, NV10TCL_LIGHTING_ENABLE, 1); - OUT_RING(chan, ctx->Light.Enabled ? 1 : 0); - BEGIN_RING(chan, celsius, NV10TCL_NORMALIZE_ENABLE, 1); - OUT_RING(chan, ctx->Transform.Normalize ? 1 : 0); + BEGIN_RING(chan, celsius, NV10_3D_LIGHTING_ENABLE, 1); + OUT_RINGb(chan, ctx->Light.Enabled); + BEGIN_RING(chan, celsius, NV10_3D_NORMALIZE_ENABLE, 1); + OUT_RINGb(chan, ctx->Transform.Normalize); } void @@ -193,16 +193,16 @@ nv10_emit_light_model(struct gl_context *ctx, int emit) struct nouveau_grobj *celsius = context_eng3d(ctx); struct gl_lightmodel *m = &ctx->Light.Model; - BEGIN_RING(chan, celsius, NV10TCL_SEPARATE_SPECULAR_ENABLE, 1); - OUT_RING(chan, m->ColorControl == GL_SEPARATE_SPECULAR_COLOR ? 1 : 0); + BEGIN_RING(chan, celsius, NV10_3D_SEPARATE_SPECULAR_ENABLE, 1); + OUT_RINGb(chan, m->ColorControl == GL_SEPARATE_SPECULAR_COLOR); - BEGIN_RING(chan, celsius, NV10TCL_LIGHT_MODEL, 1); + BEGIN_RING(chan, celsius, NV10_3D_LIGHT_MODEL, 1); OUT_RING(chan, ((m->LocalViewer ? - NV10TCL_LIGHT_MODEL_LOCAL_VIEWER : 0) | + NV10_3D_LIGHT_MODEL_LOCAL_VIEWER : 0) | (NEED_SECONDARY_COLOR(ctx) ? - NV10TCL_LIGHT_MODEL_SEPARATE_SPECULAR : 0) | + NV10_3D_LIGHT_MODEL_SEPARATE_SPECULAR : 0) | (!ctx->Light.Enabled && ctx->Fog.ColorSumEnabled ? - NV10TCL_LIGHT_MODEL_VERTEX_SPECULAR : 0))); + NV10_3D_LIGHT_MODEL_VERTEX_SPECULAR : 0))); } static float @@ -281,20 +281,20 @@ nv10_emit_light_source(struct gl_context *ctx, int emit) struct gl_light *l = &ctx->Light.Light[i]; if (l->_Flags & LIGHT_POSITIONAL) { - BEGIN_RING(chan, celsius, NV10TCL_LIGHT_POSITION_X(i), 3); + BEGIN_RING(chan, celsius, NV10_3D_LIGHT_POSITION_X(i), 3); OUT_RINGp(chan, l->_Position, 3); BEGIN_RING(chan, celsius, - NV10TCL_LIGHT_ATTENUATION_CONSTANT(i), 3); + NV10_3D_LIGHT_ATTENUATION_CONSTANT(i), 3); OUT_RINGf(chan, l->ConstantAttenuation); OUT_RINGf(chan, l->LinearAttenuation); OUT_RINGf(chan, l->QuadraticAttenuation); } else { - BEGIN_RING(chan, celsius, NV10TCL_LIGHT_DIRECTION_X(i), 3); + BEGIN_RING(chan, celsius, NV10_3D_LIGHT_DIRECTION_X(i), 3); OUT_RINGp(chan, l->_VP_inf_norm, 3); - BEGIN_RING(chan, celsius, NV10TCL_LIGHT_HALF_VECTOR_X(i), 3); + BEGIN_RING(chan, celsius, NV10_3D_LIGHT_HALF_VECTOR_X(i), 3); OUT_RINGp(chan, l->_h_inf_norm, 3); } @@ -303,7 +303,7 @@ nv10_emit_light_source(struct gl_context *ctx, int emit) nv10_get_spot_coeff(l, k); - BEGIN_RING(chan, celsius, NV10TCL_LIGHT_SPOT_CUTOFF_A(i), 7); + BEGIN_RING(chan, celsius, NV10_3D_LIGHT_SPOT_CUTOFF(i, 0), 7); OUT_RINGp(chan, k, 7); } } @@ -335,11 +335,11 @@ nv10_emit_material_ambient(struct gl_context *ctx, int emit) ZERO_3V(c_factor); } - BEGIN_RING(chan, celsius, NV10TCL_LIGHT_MODEL_AMBIENT_R, 3); + BEGIN_RING(chan, celsius, NV10_3D_LIGHT_MODEL_AMBIENT_R, 3); OUT_RINGp(chan, c_scene, 3); if (ctx->Light.ColorMaterialEnabled) { - BEGIN_RING(chan, celsius, NV10TCL_MATERIAL_FACTOR_R, 3); + BEGIN_RING(chan, celsius, NV10_3D_MATERIAL_FACTOR_R, 3); OUT_RINGp(chan, c_factor, 3); } @@ -349,7 +349,7 @@ nv10_emit_material_ambient(struct gl_context *ctx, int emit) l->Ambient : l->_MatAmbient[0]); - BEGIN_RING(chan, celsius, NV10TCL_LIGHT_AMBIENT_R(i), 3); + BEGIN_RING(chan, celsius, NV10_3D_LIGHT_AMBIENT_R(i), 3); OUT_RINGp(chan, c_light, 3); } } @@ -362,7 +362,7 @@ nv10_emit_material_diffuse(struct gl_context *ctx, int emit) GLfloat (*mat)[4] = ctx->Light.Material.Attrib; struct gl_light *l; - BEGIN_RING(chan, celsius, NV10TCL_MATERIAL_FACTOR_A, 1); + BEGIN_RING(chan, celsius, NV10_3D_MATERIAL_FACTOR_A, 1); OUT_RINGf(chan, mat[MAT_ATTRIB_FRONT_DIFFUSE][3]); foreach(l, &ctx->Light.EnabledList) { @@ -371,7 +371,7 @@ nv10_emit_material_diffuse(struct gl_context *ctx, int emit) l->Diffuse : l->_MatDiffuse[0]); - BEGIN_RING(chan, celsius, NV10TCL_LIGHT_DIFFUSE_R(i), 3); + BEGIN_RING(chan, celsius, NV10_3D_LIGHT_DIFFUSE_R(i), 3); OUT_RINGp(chan, c_light, 3); } } @@ -389,7 +389,7 @@ nv10_emit_material_specular(struct gl_context *ctx, int emit) l->Specular : l->_MatSpecular[0]); - BEGIN_RING(chan, celsius, NV10TCL_LIGHT_SPECULAR_R(i), 3); + BEGIN_RING(chan, celsius, NV10_3D_LIGHT_SPECULAR_R(i), 3); OUT_RINGp(chan, c_light, 3); } } @@ -430,7 +430,7 @@ nv10_emit_material_shininess(struct gl_context *ctx, int emit) CLAMP(mat[MAT_ATTRIB_FRONT_SHININESS][0], 0, 1024), k); - BEGIN_RING(chan, celsius, NV10TCL_MATERIAL_SHININESS(0), 6); + BEGIN_RING(chan, celsius, NV10_3D_MATERIAL_SHININESS(0), 6); OUT_RINGp(chan, k, 6); } @@ -447,7 +447,7 @@ nv10_emit_modelview(struct gl_context *ctx, int emit) if (ctx->Light._NeedEyeCoords || ctx->Fog.Enabled || (ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD)) { - BEGIN_RING(chan, celsius, NV10TCL_MODELVIEW0_MATRIX(0), 16); + BEGIN_RING(chan, celsius, NV10_3D_MODELVIEW_MATRIX(0, 0), 16); OUT_RINGm(chan, m->m); } @@ -456,7 +456,7 @@ nv10_emit_modelview(struct gl_context *ctx, int emit) int i, j; BEGIN_RING(chan, celsius, - NV10TCL_INVERSE_MODELVIEW0_MATRIX(0), 12); + NV10_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]); @@ -485,7 +485,7 @@ nv10_emit_projection(struct gl_context *ctx, int emit) if (nctx->fallback == HWTNL) _math_matrix_mul_matrix(&m, &m, &ctx->_ModelProjectMatrix); - BEGIN_RING(chan, celsius, NV10TCL_PROJECTION_MATRIX(0), 16); + BEGIN_RING(chan, celsius, NV10_3D_PROJECTION_MATRIX(0), 16); OUT_RINGm(chan, m.m); _math_matrix_dtr(&m); diff --git a/src/mesa/drivers/dri/nouveau/nv20_3d.xml.h b/src/mesa/drivers/dri/nouveau/nv20_3d.xml.h new file mode 100644 index 0000000000..c8ed861961 --- /dev/null +++ b/src/mesa/drivers/dri/nouveau/nv20_3d.xml.h @@ -0,0 +1,2076 @@ +#ifndef NV20_3D_XML +#define NV20_3D_XML + +/* Autogenerated file, DO NOT EDIT manually! + +This file was generated by the rules-ng-ng headergen tool in this git repository: +http://0x04.net/cgit/index.cgi/rules-ng-ng +git clone git://0x04.net/rules-ng-ng + +The rules-ng-ng source files this header was generated from are: +- nv20_3d.xml ( 21073 bytes, from 2010-11-15 02:24:38) +- copyright.xml ( 6452 bytes, from 2010-11-15 15:10:58) +- nv10_3d.xml ( 18449 bytes, from 2010-11-15 02:24:38) +- nv_defs.xml ( 4437 bytes, from 2010-11-01 00:28:46) +- nv_3ddefs.xml ( 16394 bytes, from 2010-11-01 00:28:46) +- nv_object.xml ( 11547 bytes, from 2010-11-13 23:32:57) +- nvchipsets.xml ( 3074 bytes, from 2010-11-13 23:32:57) + +Copyright (C) 2006-2010 by the following authors: +- Artur Huillet <arthur.huillet@free.fr> (ahuillet) +- Ben Skeggs (darktama, darktama_) +- B. R. <koala_br@users.sourceforge.net> (koala_br) +- Carlos Martin <carlosmn@users.sf.net> (carlosmn) +- Christoph Bumiller <e0425955@student.tuwien.ac.at> (calim, chrisbmr) +- Dawid Gajownik <gajownik@users.sf.net> (gajownik) +- Dmitry Baryshkov +- Dmitry Eremin-Solenikov <lumag@users.sf.net> (lumag) +- EdB <edb_@users.sf.net> (edb_) +- Erik Waling <erikwailing@users.sf.net> (erikwaling) +- Francisco Jerez <currojerez@riseup.net> (curro) +- imirkin <imirkin@users.sf.net> (imirkin) +- jb17bsome <jb17bsome@bellsouth.net> (jb17bsome) +- Jeremy Kolb <kjeremy@users.sf.net> (kjeremy) +- Laurent Carlier <lordheavym@gmail.com> (lordheavy) +- Luca Barbieri <luca@luca-barbieri.com> (lb, lb1) +- Maarten Maathuis <madman2003@gmail.com> (stillunknown) +- Marcin Kościelnicki <koriakin@0x04.net> (mwk, koriakin) +- Mark Carey <mark.carey@gmail.com> (careym) +- Matthieu Castet <matthieu.castet@parrot.com> (mat-c) +- nvidiaman <nvidiaman@users.sf.net> (nvidiaman) +- Patrice Mandin <patmandin@gmail.com> (pmandin, pmdata) +- Pekka Paalanen <pq@iki.fi> (pq, ppaalanen) +- Peter Popov <ironpeter@users.sf.net> (ironpeter) +- Richard Hughes <hughsient@users.sf.net> (hughsient) +- Rudi Cilibrasi <cilibrar@users.sf.net> (cilibrar) +- Serge Martin +- Simon Raffeiner +- Stephane Loeuillet <leroutier@users.sf.net> (leroutier) +- Stephane Marchesin <stephane.marchesin@gmail.com> (marcheu) +- sturmflut <sturmflut@users.sf.net> (sturmflut) +- Sylvain Munaut <tnt@246tNt.com> +- Victor Stinner <victor.stinner@haypocalc.com> (haypo) +- Wladmir van der Laan <laanwj@gmail.com> (miathan6) +- Younes Manton <younes.m@gmail.com> (ymanton) + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial +portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + + +#define NV20_VERTEX_ATTR_POS 0x00000000 +#define NV20_VERTEX_ATTR_NORMAL 0x00000002 +#define NV20_VERTEX_ATTR_COLOR0 0x00000003 +#define NV20_VERTEX_ATTR_COLOR1 0x00000004 +#define NV20_VERTEX_ATTR_FOG 0x00000005 +#define NV20_VERTEX_ATTR_TEX0 0x00000009 +#define NV20_VERTEX_ATTR_TEX1 0x0000000a +#define NV20_VERTEX_ATTR_TEX2 0x0000000b +#define NV20_VERTEX_ATTR_TEX3 0x0000000c + + + +#define NV20_3D_FLIP_SET_READ 0x00000120 + +#define NV20_3D_FLIP_SET_WRITE 0x00000124 + +#define NV20_3D_FLIP_MAX 0x00000128 + +#define NV20_3D_FLIP_INCR_WRITE 0x0000012c + +#define NV20_3D_FLIP_WAIT 0x00000130 + +#define NV20_3D_DMA_NOTIFY 0x00000180 + +#define NV20_3D_DMA_TEXTURE0 0x00000184 + +#define NV20_3D_DMA_TEXTURE1 0x00000188 + +#define NV20_3D_DMA_COLOR 0x00000194 + +#define NV20_3D_DMA_ZETA 0x00000198 + +#define NV20_3D_RT_HORIZ 0x00000200 +#define NV20_3D_RT_HORIZ_X__MASK 0x0000ffff +#define NV20_3D_RT_HORIZ_X__SHIFT 0 +#define NV20_3D_RT_HORIZ_W__MASK 0xffff0000 +#define NV20_3D_RT_HORIZ_W__SHIFT 16 + +#define NV20_3D_RT_VERT 0x00000204 +#define NV20_3D_RT_VERT_Y__MASK 0x0000ffff +#define NV20_3D_RT_VERT_Y__SHIFT 0 +#define NV20_3D_RT_VERT_H__MASK 0xffff0000 +#define NV20_3D_RT_VERT_H__SHIFT 16 + +#define NV20_3D_RT_FORMAT 0x00000208 +#define NV20_3D_RT_FORMAT_TYPE__MASK 0x00000f00 +#define NV20_3D_RT_FORMAT_TYPE__SHIFT 8 +#define NV20_3D_RT_FORMAT_TYPE_LINEAR 0x00000100 +#define NV20_3D_RT_FORMAT_TYPE_SWIZZLED 0x00000200 +#define NV20_3D_RT_FORMAT_DEPTH__MASK 0x00000030 +#define NV20_3D_RT_FORMAT_DEPTH__SHIFT 4 +#define NV20_3D_RT_FORMAT_DEPTH_Z16 0x00000010 +#define NV20_3D_RT_FORMAT_DEPTH_Z24S8 0x00000020 +#define NV20_3D_RT_FORMAT_COLOR__MASK 0x0000000f +#define NV20_3D_RT_FORMAT_COLOR__SHIFT 0 +#define NV20_3D_RT_FORMAT_COLOR_R5G6B5 0x00000003 +#define NV20_3D_RT_FORMAT_COLOR_X8R8G8B8 0x00000005 +#define NV20_3D_RT_FORMAT_COLOR_A8R8G8B8 0x00000008 +#define NV20_3D_RT_FORMAT_COLOR_B8 0x00000009 + +#define NV20_3D_RT_PITCH 0x0000020c +#define NV20_3D_RT_PITCH_COLOR_PITCH__MASK 0x0000ffff +#define NV20_3D_RT_PITCH_COLOR_PITCH__SHIFT 0 +#define NV20_3D_RT_PITCH_ZETA_PITCH__MASK 0xffff0000 +#define NV20_3D_RT_PITCH_ZETA_PITCH__SHIFT 16 + +#define NV20_3D_COLOR_OFFSET 0x00000210 + +#define NV20_3D_ZETA_OFFSET 0x00000214 + +#define NV20_3D_UNK0290 0x00000290 + +#define NV20_3D_VIEWPORT_CLIP_MODE 0x000002b4 + +#define NV20_3D_VIEWPORT_CLIP_HORIZ(i0) (0x000002c0 + 0x4*(i0)) +#define NV20_3D_VIEWPORT_CLIP_HORIZ__ESIZE 0x00000004 +#define NV20_3D_VIEWPORT_CLIP_HORIZ__LEN 0x00000008 +#define NV20_3D_VIEWPORT_CLIP_HORIZ_CLIP_L__MASK 0x000007ff +#define NV20_3D_VIEWPORT_CLIP_HORIZ_CLIP_L__SHIFT 0 +#define NV20_3D_VIEWPORT_CLIP_HORIZ_CLIP_R__MASK 0x07ff0000 +#define NV20_3D_VIEWPORT_CLIP_HORIZ_CLIP_R__SHIFT 16 + +#define NV20_3D_VIEWPORT_CLIP_VERT(i0) (0x000002e0 + 0x4*(i0)) +#define NV20_3D_VIEWPORT_CLIP_VERT__ESIZE 0x00000004 +#define NV20_3D_VIEWPORT_CLIP_VERT__LEN 0x00000008 +#define NV20_3D_VIEWPORT_CLIP_VERT_CLIP_T__MASK 0x000007ff +#define NV20_3D_VIEWPORT_CLIP_VERT_CLIP_T__SHIFT 0 +#define NV20_3D_VIEWPORT_CLIP_VERT_CLIP_B__MASK 0x07ff0000 +#define NV20_3D_VIEWPORT_CLIP_VERT_CLIP_B__SHIFT 16 + +#define NV20_3D_ALPHA_FUNC_ENABLE 0x00000300 + +#define NV20_3D_BLEND_FUNC_ENABLE 0x00000304 + +#define NV20_3D_CULL_FACE_ENABLE 0x00000308 + +#define NV20_3D_DEPTH_TEST_ENABLE 0x0000030c + +#define NV20_3D_DITHER_ENABLE 0x00000310 + +#define NV20_3D_LIGHTING_ENABLE 0x00000314 + +#define NV20_3D_POINT_PARAMETERS_ENABLE 0x00000318 + +#define NV20_3D_POINT_SMOOTH_ENABLE 0x0000031c + +#define NV20_3D_LINE_SMOOTH_ENABLE 0x00000320 + +#define NV20_3D_POLYGON_SMOOTH_ENABLE 0x00000324 + +#define NV20_3D_STENCIL_ENABLE 0x0000032c + +#define NV20_3D_POLYGON_OFFSET_POINT_ENABLE 0x00000330 + +#define NV20_3D_POLYGON_OFFSET_LINE_ENABLE 0x00000334 + +#define NV20_3D_POLYGON_OFFSET_FILL_ENABLE 0x00000338 + +#define NV20_3D_ALPHA_FUNC_FUNC 0x0000033c +#define NV20_3D_ALPHA_FUNC_FUNC_NEVER 0x00000200 +#define NV20_3D_ALPHA_FUNC_FUNC_LESS 0x00000201 +#define NV20_3D_ALPHA_FUNC_FUNC_EQUAL 0x00000202 +#define NV20_3D_ALPHA_FUNC_FUNC_LEQUAL 0x00000203 +#define NV20_3D_ALPHA_FUNC_FUNC_GREATER 0x00000204 +#define NV20_3D_ALPHA_FUNC_FUNC_NOTEQUAL 0x00000205 +#define NV20_3D_ALPHA_FUNC_FUNC_GEQUAL 0x00000206 +#define NV20_3D_ALPHA_FUNC_FUNC_ALWAYS 0x00000207 + +#define NV20_3D_ALPHA_FUNC_REF 0x00000340 + +#define NV20_3D_BLEND_FUNC_SRC 0x00000344 +#define NV20_3D_BLEND_FUNC_SRC_ZERO 0x00000000 +#define NV20_3D_BLEND_FUNC_SRC_ONE 0x00000001 +#define NV20_3D_BLEND_FUNC_SRC_SRC_COLOR 0x00000300 +#define NV20_3D_BLEND_FUNC_SRC_ONE_MINUS_SRC_COLOR 0x00000301 +#define NV20_3D_BLEND_FUNC_SRC_SRC_ALPHA 0x00000302 +#define NV20_3D_BLEND_FUNC_SRC_ONE_MINUS_SRC_ALPHA 0x00000303 +#define NV20_3D_BLEND_FUNC_SRC_DST_ALPHA 0x00000304 +#define NV20_3D_BLEND_FUNC_SRC_ONE_MINUS_DST_ALPHA 0x00000305 +#define NV20_3D_BLEND_FUNC_SRC_DST_COLOR 0x00000306 +#define NV20_3D_BLEND_FUNC_SRC_ONE_MINUS_DST_COLOR 0x00000307 +#define NV20_3D_BLEND_FUNC_SRC_SRC_ALPHA_SATURATE 0x00000308 +#define NV20_3D_BLEND_FUNC_SRC_CONSTANT_COLOR 0x00008001 +#define NV20_3D_BLEND_FUNC_SRC_ONE_MINUS_CONSTANT_COLOR 0x00008002 +#define NV20_3D_BLEND_FUNC_SRC_CONSTANT_ALPHA 0x00008003 +#define NV20_3D_BLEND_FUNC_SRC_ONE_MINUS_CONSTANT_ALPHA 0x00008004 + +#define NV20_3D_BLEND_FUNC_DST 0x00000348 +#define NV20_3D_BLEND_FUNC_DST_ZERO 0x00000000 +#define NV20_3D_BLEND_FUNC_DST_ONE 0x00000001 +#define NV20_3D_BLEND_FUNC_DST_SRC_COLOR 0x00000300 +#define NV20_3D_BLEND_FUNC_DST_ONE_MINUS_SRC_COLOR 0x00000301 +#define NV20_3D_BLEND_FUNC_DST_SRC_ALPHA 0x00000302 +#define NV20_3D_BLEND_FUNC_DST_ONE_MINUS_SRC_ALPHA 0x00000303 +#define NV20_3D_BLEND_FUNC_DST_DST_ALPHA 0x00000304 +#define NV20_3D_BLEND_FUNC_DST_ONE_MINUS_DST_ALPHA 0x00000305 +#define NV20_3D_BLEND_FUNC_DST_DST_COLOR 0x00000306 +#define NV20_3D_BLEND_FUNC_DST_ONE_MINUS_DST_COLOR 0x00000307 +#define NV20_3D_BLEND_FUNC_DST_SRC_ALPHA_SATURATE 0x00000308 +#define NV20_3D_BLEND_FUNC_DST_CONSTANT_COLOR 0x00008001 +#define NV20_3D_BLEND_FUNC_DST_ONE_MINUS_CONSTANT_COLOR 0x00008002 +#define NV20_3D_BLEND_FUNC_DST_CONSTANT_ALPHA 0x00008003 +#define NV20_3D_BLEND_FUNC_DST_ONE_MINUS_CONSTANT_ALPHA 0x00008004 + +#define NV20_3D_BLEND_COLOR 0x0000034c +#define NV20_3D_BLEND_COLOR_B__MASK 0x000000ff +#define NV20_3D_BLEND_COLOR_B__SHIFT 0 +#define NV20_3D_BLEND_COLOR_G__MASK 0x0000ff00 +#define NV20_3D_BLEND_COLOR_G__SHIFT 8 +#define NV20_3D_BLEND_COLOR_R__MASK 0x00ff0000 +#define NV20_3D_BLEND_COLOR_R__SHIFT 16 +#define NV20_3D_BLEND_COLOR_A__MASK 0xff000000 +#define NV20_3D_BLEND_COLOR_A__SHIFT 24 + +#define NV20_3D_BLEND_EQUATION 0x00000350 +#define NV20_3D_BLEND_EQUATION_FUNC_ADD 0x00008006 +#define NV20_3D_BLEND_EQUATION_MIN 0x00008007 +#define NV20_3D_BLEND_EQUATION_MAX 0x00008008 +#define NV20_3D_BLEND_EQUATION_FUNC_SUBTRACT 0x0000800a +#define NV20_3D_BLEND_EQUATION_FUNC_REVERSE_SUBTRACT 0x0000800b + +#define NV20_3D_DEPTH_FUNC 0x00000354 +#define NV20_3D_DEPTH_FUNC_NEVER 0x00000200 +#define NV20_3D_DEPTH_FUNC_LESS 0x00000201 +#define NV20_3D_DEPTH_FUNC_EQUAL 0x00000202 +#define NV20_3D_DEPTH_FUNC_LEQUAL 0x00000203 +#define NV20_3D_DEPTH_FUNC_GREATER 0x00000204 +#define NV20_3D_DEPTH_FUNC_NOTEQUAL 0x00000205 +#define NV20_3D_DEPTH_FUNC_GEQUAL 0x00000206 +#define NV20_3D_DEPTH_FUNC_ALWAYS 0x00000207 + +#define NV20_3D_COLOR_MASK 0x00000358 +#define NV20_3D_COLOR_MASK_B 0x00000001 +#define NV20_3D_COLOR_MASK_G 0x00000100 +#define NV20_3D_COLOR_MASK_R 0x00010000 +#define NV20_3D_COLOR_MASK_A 0x01000000 + +#define NV20_3D_DEPTH_WRITE_ENABLE 0x0000035c + +#define NV20_3D_STENCIL_MASK 0x00000360 + +#define NV20_3D_STENCIL_FUNC_FUNC 0x00000364 +#define NV20_3D_STENCIL_FUNC_FUNC_NEVER 0x00000200 +#define NV20_3D_STENCIL_FUNC_FUNC_LESS 0x00000201 +#define NV20_3D_STENCIL_FUNC_FUNC_EQUAL 0x00000202 +#define NV20_3D_STENCIL_FUNC_FUNC_LEQUAL 0x00000203 +#define NV20_3D_STENCIL_FUNC_FUNC_GREATER 0x00000204 +#define NV20_3D_STENCIL_FUNC_FUNC_NOTEQUAL 0x00000205 +#define NV20_3D_STENCIL_FUNC_FUNC_GEQUAL 0x00000206 +#define NV20_3D_STENCIL_FUNC_FUNC_ALWAYS 0x00000207 + +#define NV20_3D_STENCIL_FUNC_REF 0x00000368 + +#define NV20_3D_STENCIL_FUNC_MASK 0x0000036c + +#define NV20_3D_STENCIL_OP_FAIL 0x00000370 +#define NV20_3D_STENCIL_OP_FAIL_ZERO 0x00000000 +#define NV20_3D_STENCIL_OP_FAIL_INVERT 0x0000150a +#define NV20_3D_STENCIL_OP_FAIL_KEEP 0x00001e00 +#define NV20_3D_STENCIL_OP_FAIL_REPLACE 0x00001e01 +#define NV20_3D_STENCIL_OP_FAIL_INCR 0x00001e02 +#define NV20_3D_STENCIL_OP_FAIL_DECR 0x00001e03 +#define NV20_3D_STENCIL_OP_FAIL_INCR_WRAP 0x00008507 +#define NV20_3D_STENCIL_OP_FAIL_DECR_WRAP 0x00008508 + +#define NV20_3D_STENCIL_OP_ZFAIL 0x00000374 +#define NV20_3D_STENCIL_OP_ZFAIL_ZERO 0x00000000 +#define NV20_3D_STENCIL_OP_ZFAIL_INVERT 0x0000150a +#define NV20_3D_STENCIL_OP_ZFAIL_KEEP 0x00001e00 +#define NV20_3D_STENCIL_OP_ZFAIL_REPLACE 0x00001e01 +#define NV20_3D_STENCIL_OP_ZFAIL_INCR 0x00001e02 +#define NV20_3D_STENCIL_OP_ZFAIL_DECR 0x00001e03 +#define NV20_3D_STENCIL_OP_ZFAIL_INCR_WRAP 0x00008507 +#define NV20_3D_STENCIL_OP_ZFAIL_DECR_WRAP 0x00008508 + +#define NV20_3D_STENCIL_OP_ZPASS 0x00000378 +#define NV20_3D_STENCIL_OP_ZPASS_ZERO 0x00000000 +#define NV20_3D_STENCIL_OP_ZPASS_INVERT 0x0000150a +#define NV20_3D_STENCIL_OP_ZPASS_KEEP 0x00001e00 +#define NV20_3D_STENCIL_OP_ZPASS_REPLACE 0x00001e01 +#define NV20_3D_STENCIL_OP_ZPASS_INCR 0x00001e02 +#define NV20_3D_STENCIL_OP_ZPASS_DECR 0x00001e03 +#define NV20_3D_STENCIL_OP_ZPASS_INCR_WRAP 0x00008507 +#define NV20_3D_STENCIL_OP_ZPASS_DECR_WRAP 0x00008508 + +#define NV20_3D_SHADE_MODEL 0x0000037c +#define NV20_3D_SHADE_MODEL_FLAT 0x00001d00 +#define NV20_3D_SHADE_MODEL_SMOOTH 0x00001d01 + +#define NV20_3D_LINE_WIDTH 0x00000380 + +#define NV20_3D_POLYGON_OFFSET_FACTOR 0x00000384 + +#define NV20_3D_POLYGON_OFFSET_UNITS 0x00000388 + +#define NV20_3D_POLYGON_MODE_FRONT 0x0000038c +#define NV20_3D_POLYGON_MODE_FRONT_POINT 0x00001b00 +#define NV20_3D_POLYGON_MODE_FRONT_LINE 0x00001b01 +#define NV20_3D_POLYGON_MODE_FRONT_FILL 0x00001b02 + +#define NV20_3D_POLYGON_MODE_BACK 0x00000390 +#define NV20_3D_POLYGON_MODE_BACK_POINT 0x00001b00 +#define NV20_3D_POLYGON_MODE_BACK_LINE 0x00001b01 +#define NV20_3D_POLYGON_MODE_BACK_FILL 0x00001b02 + +#define NV20_3D_DEPTH_RANGE_NEAR 0x00000394 + +#define NV20_3D_DEPTH_RANGE_FAR 0x00000398 + +#define NV20_3D_CULL_FACE 0x0000039c +#define NV20_3D_CULL_FACE_FRONT 0x00000404 +#define NV20_3D_CULL_FACE_BACK 0x00000405 +#define NV20_3D_CULL_FACE_FRONT_AND_BACK 0x00000408 + +#define NV20_3D_FRONT_FACE 0x000003a0 +#define NV20_3D_FRONT_FACE_CW 0x00000900 +#define NV20_3D_FRONT_FACE_CCW 0x00000901 + +#define NV20_3D_DMA_FENCE 0x000001a4 + +#define NV20_3D_DMA_QUERY 0x000001a8 + + +#define NV20_3D_VERTEX_POS_3F 0x00001500 + + +#define NV20_3D_VERTEX_POS_3F_X 0x00001500 + +#define NV20_3D_VERTEX_POS_3F_Y 0x00001504 + +#define NV20_3D_VERTEX_POS_3F_Z 0x00001508 + +#define NV20_3D_VERTEX_POS_4F 0x00001518 + + +#define NV20_3D_VERTEX_POS_4F_X 0x00001518 + +#define NV20_3D_VERTEX_POS_4F_Y 0x0000151c + +#define NV20_3D_VERTEX_POS_4F_Z 0x00001520 + +#define NV20_3D_VERTEX_POS_4F_W 0x00001524 + +#define NV20_3D_VERTEX_POS_3I 0x00001528 + + +#define NV20_3D_VERTEX_POS_3I_XY 0x00001528 +#define NV20_3D_VERTEX_POS_3I_XY_X__MASK 0x0000ffff +#define NV20_3D_VERTEX_POS_3I_XY_X__SHIFT 0 +#define NV20_3D_VERTEX_POS_3I_XY_Y__MASK 0xffff0000 +#define NV20_3D_VERTEX_POS_3I_XY_Y__SHIFT 16 + +#define NV20_3D_VERTEX_POS_3I_Z 0x0000152c +#define NV20_3D_VERTEX_POS_3I_Z_Z__MASK 0x0000ffff +#define NV20_3D_VERTEX_POS_3I_Z_Z__SHIFT 0 + +#define NV20_3D_VERTEX_NOR_3F 0x00001530 + + +#define NV20_3D_VERTEX_NOR_3F_X 0x00001530 + +#define NV20_3D_VERTEX_NOR_3F_Y 0x00001534 + +#define NV20_3D_VERTEX_NOR_3F_Z 0x00001538 + +#define NV20_3D_VERTEX_NOR_3I 0x00001540 + + +#define NV20_3D_VERTEX_NOR_3I_XY 0x00001540 +#define NV20_3D_VERTEX_NOR_3I_XY_X__MASK 0x0000ffff +#define NV20_3D_VERTEX_NOR_3I_XY_X__SHIFT 0 +#define NV20_3D_VERTEX_NOR_3I_XY_Y__MASK 0xffff0000 +#define NV20_3D_VERTEX_NOR_3I_XY_Y__SHIFT 16 + +#define NV20_3D_VERTEX_NOR_3I_Z 0x00001544 +#define NV20_3D_VERTEX_NOR_3I_Z_Z__MASK 0x0000ffff +#define NV20_3D_VERTEX_NOR_3I_Z_Z__SHIFT 0 + +#define NV20_3D_VERTEX_COL_4F 0x00001550 + + +#define NV20_3D_VERTEX_COL_4F_R 0x00001550 + +#define NV20_3D_VERTEX_COL_4F_G 0x00001554 + +#define NV20_3D_VERTEX_COL_4F_B 0x00001558 + +#define NV20_3D_VERTEX_COL_4F_A 0x0000155c + +#define NV20_3D_VERTEX_COL_3F 0x00001560 + + +#define NV20_3D_VERTEX_COL_3F_R 0x00001560 + +#define NV20_3D_VERTEX_COL_3F_G 0x00001564 + +#define NV20_3D_VERTEX_COL_3F_B 0x00001568 + +#define NV20_3D_VERTEX_COL_4I 0x0000156c +#define NV20_3D_VERTEX_COL_4I_R__MASK 0x000000ff +#define NV20_3D_VERTEX_COL_4I_R__SHIFT 0 +#define NV20_3D_VERTEX_COL_4I_G__MASK 0x0000ff00 +#define NV20_3D_VERTEX_COL_4I_G__SHIFT 8 +#define NV20_3D_VERTEX_COL_4I_B__MASK 0x00ff0000 +#define NV20_3D_VERTEX_COL_4I_B__SHIFT 16 +#define NV20_3D_VERTEX_COL_4I_A__MASK 0xff000000 +#define NV20_3D_VERTEX_COL_4I_A__SHIFT 24 + +#define NV20_3D_VERTEX_COL2_3F 0x00001580 + + +#define NV20_3D_VERTEX_COL2_3F_R 0x00001580 + +#define NV20_3D_VERTEX_COL2_3F_G 0x00001584 + +#define NV20_3D_VERTEX_COL2_3F_B 0x00001588 + +#define NV20_3D_VERTEX_COL2_3I 0x0000158c +#define NV20_3D_VERTEX_COL2_3I_R__MASK 0x000000ff +#define NV20_3D_VERTEX_COL2_3I_R__SHIFT 0 +#define NV20_3D_VERTEX_COL2_3I_G__MASK 0x0000ff00 +#define NV20_3D_VERTEX_COL2_3I_G__SHIFT 8 +#define NV20_3D_VERTEX_COL2_3I_B__MASK 0x00ff0000 +#define NV20_3D_VERTEX_COL2_3I_B__SHIFT 16 + +#define NV20_3D_VERTEX_TX0_2F 0x00001590 + + +#define NV20_3D_VERTEX_TX0_2F_S 0x00001590 + +#define NV20_3D_VERTEX_TX0_2F_T 0x00001594 + +#define NV20_3D_VERTEX_TX0_2I 0x00001598 +#define NV20_3D_VERTEX_TX0_2I_S__MASK 0x0000ffff +#define NV20_3D_VERTEX_TX0_2I_S__SHIFT 0 +#define NV20_3D_VERTEX_TX0_2I_T__MASK 0xffff0000 +#define NV20_3D_VERTEX_TX0_2I_T__SHIFT 16 + +#define NV20_3D_VERTEX_TX0_4F 0x000015a0 + + +#define NV20_3D_VERTEX_TX0_4F_S 0x000015a0 + +#define NV20_3D_VERTEX_TX0_4F_T 0x000015a4 + +#define NV20_3D_VERTEX_TX0_4F_R 0x000015a8 + +#define NV20_3D_VERTEX_TX0_4F_Q 0x000015ac + +#define NV20_3D_VERTEX_TX0_4I 0x000015b0 + + +#define NV20_3D_VERTEX_TX0_4I_ST 0x000015b0 +#define NV20_3D_VERTEX_TX0_4I_ST_S__MASK 0x0000ffff +#define NV20_3D_VERTEX_TX0_4I_ST_S__SHIFT 0 +#define NV20_3D_VERTEX_TX0_4I_ST_T__MASK 0xffff0000 +#define NV20_3D_VERTEX_TX0_4I_ST_T__SHIFT 16 + +#define NV20_3D_VERTEX_TX0_4I_RQ 0x000015b4 +#define NV20_3D_VERTEX_TX0_4I_RQ_R__MASK 0x0000ffff +#define NV20_3D_VERTEX_TX0_4I_RQ_R__SHIFT 0 +#define NV20_3D_VERTEX_TX0_4I_RQ_Q__MASK 0xffff0000 +#define NV20_3D_VERTEX_TX0_4I_RQ_Q__SHIFT 16 + +#define NV20_3D_VERTEX_TX1_2F 0x000015b8 + + +#define NV20_3D_VERTEX_TX1_2F_S 0x000015b8 + +#define NV20_3D_VERTEX_TX1_2F_T 0x000015bc + +#define NV20_3D_VERTEX_TX1_2I 0x000015c0 +#define NV20_3D_VERTEX_TX1_2I_S__MASK 0x0000ffff +#define NV20_3D_VERTEX_TX1_2I_S__SHIFT 0 +#define NV20_3D_VERTEX_TX1_2I_T__MASK 0xffff0000 +#define NV20_3D_VERTEX_TX1_2I_T__SHIFT 16 + +#define NV20_3D_VERTEX_TX1_4F 0x000015c8 + + +#define NV20_3D_VERTEX_TX1_4F_S 0x000015c8 + +#define NV20_3D_VERTEX_TX1_4F_T 0x000015cc + +#define NV20_3D_VERTEX_TX1_4F_R 0x000015d0 + +#define NV20_3D_VERTEX_TX1_4F_Q 0x000015d4 + +#define NV20_3D_VERTEX_TX1_4I 0x000015d8 + + +#define NV20_3D_VERTEX_TX1_4I_ST 0x000015d8 +#define NV20_3D_VERTEX_TX1_4I_ST_S__MASK 0x0000ffff +#define NV20_3D_VERTEX_TX1_4I_ST_S__SHIFT 0 +#define NV20_3D_VERTEX_TX1_4I_ST_T__MASK 0xffff0000 +#define NV20_3D_VERTEX_TX1_4I_ST_T__SHIFT 16 + +#define NV20_3D_VERTEX_TX1_4I_RQ 0x000015dc +#define NV20_3D_VERTEX_TX1_4I_RQ_R__MASK 0x0000ffff +#define NV20_3D_VERTEX_TX1_4I_RQ_R__SHIFT 0 +#define NV20_3D_VERTEX_TX1_4I_RQ_Q__MASK 0xffff0000 +#define NV20_3D_VERTEX_TX1_4I_RQ_Q__SHIFT 16 + +#define NV20_3D_VERTEX_TX2_2F 0x000015e0 + + +#define NV20_3D_VERTEX_TX2_2F_S 0x000015e0 + +#define NV20_3D_VERTEX_TX2_2F_T 0x000015e4 + +#define NV20_3D_VERTEX_TX2_2I 0x000015e8 +#define NV20_3D_VERTEX_TX2_2I_S__MASK 0x0000ffff +#define NV20_3D_VERTEX_TX2_2I_S__SHIFT 0 +#define NV20_3D_VERTEX_TX2_2I_T__MASK 0xffff0000 +#define NV20_3D_VERTEX_TX2_2I_T__SHIFT 16 + +#define NV20_3D_VERTEX_TX2_4F 0x000015f0 + + +#define NV20_3D_VERTEX_TX2_4F_S 0x000015f0 + +#define NV20_3D_VERTEX_TX2_4F_T 0x000015f4 + +#define NV20_3D_VERTEX_TX2_4F_R 0x000015f8 + +#define NV20_3D_VERTEX_TX2_4F_Q 0x000015fc + +#define NV20_3D_VERTEX_TX2_4I 0x00001600 + + +#define NV20_3D_VERTEX_TX2_4I_ST 0x00001600 +#define NV20_3D_VERTEX_TX2_4I_ST_S__MASK 0x0000ffff +#define NV20_3D_VERTEX_TX2_4I_ST_S__SHIFT 0 +#define NV20_3D_VERTEX_TX2_4I_ST_T__MASK 0xffff0000 +#define NV20_3D_VERTEX_TX2_4I_ST_T__SHIFT 16 + +#define NV20_3D_VERTEX_TX2_4I_RQ 0x00001604 +#define NV20_3D_VERTEX_TX2_4I_RQ_R__MASK 0x0000ffff +#define NV20_3D_VERTEX_TX2_4I_RQ_R__SHIFT 0 +#define NV20_3D_VERTEX_TX2_4I_RQ_Q__MASK 0xffff0000 +#define NV20_3D_VERTEX_TX2_4I_RQ_Q__SHIFT 16 + +#define NV20_3D_VERTEX_TX3_2F 0x00001608 + + +#define NV20_3D_VERTEX_TX3_2F_S 0x00001608 + +#define NV20_3D_VERTEX_TX3_2F_T 0x0000160c + +#define NV20_3D_VERTEX_TX3_2I 0x00001610 +#define NV20_3D_VERTEX_TX3_2I_S__MASK 0x0000ffff +#define NV20_3D_VERTEX_TX3_2I_S__SHIFT 0 +#define NV20_3D_VERTEX_TX3_2I_T__MASK 0xffff0000 +#define NV20_3D_VERTEX_TX3_2I_T__SHIFT 16 + +#define NV20_3D_VERTEX_TX3_4F 0x00001620 + + +#define NV20_3D_VERTEX_TX3_4F_S 0x00001620 + +#define NV20_3D_VERTEX_TX3_4F_T 0x00001624 + +#define NV20_3D_VERTEX_TX3_4F_R 0x00001628 + +#define NV20_3D_VERTEX_TX3_4F_Q 0x0000162c + +#define NV20_3D_VERTEX_TX3_4I 0x00001630 + + +#define NV20_3D_VERTEX_TX3_4I_ST 0x00001630 +#define NV20_3D_VERTEX_TX3_4I_ST_S__MASK 0x0000ffff +#define NV20_3D_VERTEX_TX3_4I_ST_S__SHIFT 0 +#define NV20_3D_VERTEX_TX3_4I_ST_T__MASK 0xffff0000 +#define NV20_3D_VERTEX_TX3_4I_ST_T__SHIFT 16 + +#define NV20_3D_VERTEX_TX3_4I_RQ 0x00001634 +#define NV20_3D_VERTEX_TX3_4I_RQ_R__MASK 0x0000ffff +#define NV20_3D_VERTEX_TX3_4I_RQ_R__SHIFT 0 +#define NV20_3D_VERTEX_TX3_4I_RQ_Q__MASK 0xffff0000 +#define NV20_3D_VERTEX_TX3_4I_RQ_Q__SHIFT 16 + +#define NV20_3D_VERTEX_FOG_1F 0x00001698 + +#define NV20_3D_EDGEFLAG_ENABLE 0x000016bc + +#define NV20_3D_VERTEX_ATTR_4F(i0) (0x00001a00 + 0x10*(i0)) +#define NV20_3D_VERTEX_ATTR_4F__ESIZE 0x00000010 +#define NV20_3D_VERTEX_ATTR_4F__LEN 0x00000010 + + +#define NV20_3D_VERTEX_ATTR_4F_X(i0) (0x00001a00 + 0x10*(i0)) + +#define NV20_3D_VERTEX_ATTR_4F_Y(i0) (0x00001a04 + 0x10*(i0)) + +#define NV20_3D_VERTEX_ATTR_4F_Z(i0) (0x00001a08 + 0x10*(i0)) + +#define NV20_3D_VERTEX_ATTR_4F_W(i0) (0x00001a0c + 0x10*(i0)) + + +#define NV20_3D_DMA_VTXBUF0 0x0000019c + +#define NV20_3D_DMA_VTXBUF1 0x000001a0 + +#define NV20_3D_VTXBUF_VALIDATE 0x00001710 + + +#define NV20_3D_VTXBUF_OFFSET(i0) (0x00001720 + 0x4*(i0)) +#define NV20_3D_VTXBUF_OFFSET_DMA1 0x80000000 +#define NV20_3D_VTXBUF_OFFSET_OFFSET__MASK 0x0fffffff +#define NV20_3D_VTXBUF_OFFSET_OFFSET__SHIFT 0 + +#define NV20_3D_VTXBUF_FMT(i0) (0x00001760 + 0x4*(i0)) +#define NV20_3D_VTXBUF_FMT_TYPE__MASK 0x0000000f +#define NV20_3D_VTXBUF_FMT_TYPE__SHIFT 0 +#define NV20_3D_VTXBUF_FMT_TYPE_FLOAT 0x00000002 +#define NV20_3D_VTXBUF_FMT_TYPE_UBYTE 0x00000004 +#define NV20_3D_VTXBUF_FMT_TYPE_USHORT 0x00000005 +#define NV20_3D_VTXBUF_FMT_SIZE__MASK 0x000000f0 +#define NV20_3D_VTXBUF_FMT_SIZE__SHIFT 4 +#define NV20_3D_VTXBUF_FMT_STRIDE__MASK 0x0000ff00 +#define NV20_3D_VTXBUF_FMT_STRIDE__SHIFT 8 + +#define NV20_3D_VERTEX_BEGIN_END 0x000017fc +#define NV20_3D_VERTEX_BEGIN_END_STOP 0x00000000 +#define NV20_3D_VERTEX_BEGIN_END_POINTS 0x00000001 +#define NV20_3D_VERTEX_BEGIN_END_LINES 0x00000002 +#define NV20_3D_VERTEX_BEGIN_END_LINE_LOOP 0x00000003 +#define NV20_3D_VERTEX_BEGIN_END_LINE_STRIP 0x00000004 +#define NV20_3D_VERTEX_BEGIN_END_TRIANGLES 0x00000005 +#define NV20_3D_VERTEX_BEGIN_END_TRIANGLE_STRIP 0x00000006 +#define NV20_3D_VERTEX_BEGIN_END_TRIANGLE_FAN 0x00000007 +#define NV20_3D_VERTEX_BEGIN_END_QUADS 0x00000008 +#define NV20_3D_VERTEX_BEGIN_END_QUAD_STRIP 0x00000009 +#define NV20_3D_VERTEX_BEGIN_END_POLYGON 0x0000000a + +#define NV20_3D_VTXBUF_ELEMENT_U16 0x00001800 +#define NV20_3D_VTXBUF_ELEMENT_U16_I0__MASK 0x0000ffff +#define NV20_3D_VTXBUF_ELEMENT_U16_I0__SHIFT 0 +#define NV20_3D_VTXBUF_ELEMENT_U16_I1__MASK 0xffff0000 +#define NV20_3D_VTXBUF_ELEMENT_U16_I1__SHIFT 16 + +#define NV20_3D_VTXBUF_ELEMENT_U32 0x00001808 + +#define NV20_3D_VTXBUF_BATCH 0x00001810 +#define NV20_3D_VTXBUF_BATCH_OFFSET__MASK 0x00ffffff +#define NV20_3D_VTXBUF_BATCH_OFFSET__SHIFT 0 +#define NV20_3D_VTXBUF_BATCH_COUNT__MASK 0xff000000 +#define NV20_3D_VTXBUF_BATCH_COUNT__SHIFT 24 + +#define NV20_3D_VTXBUF_DATA 0x00001818 + + +#define NV20_3D_ENGINE 0x00001e94 +#define NV20_3D_ENGINE_VP 0x00000002 +#define NV20_3D_ENGINE_FIXED 0x00000004 + +#define NV20_3D_VP_UPLOAD_INST(i0) (0x00000b00 + 0x4*(i0)) +#define NV20_3D_VP_UPLOAD_INST__ESIZE 0x00000004 +#define NV20_3D_VP_UPLOAD_INST__LEN 0x00000004 + +#define NV20_3D_VP_UPLOAD_CONST(i0) (0x00000b80 + 0x4*(i0)) +#define NV20_3D_VP_UPLOAD_CONST__ESIZE 0x00000004 +#define NV20_3D_VP_UPLOAD_CONST__LEN 0x00000004 + +#define NV20_3D_VP_UPLOAD_FROM_ID 0x00001e9c + +#define NV20_3D_VP_START_FROM_ID 0x00001ea0 + +#define NV20_3D_VP_UPLOAD_CONST_ID 0x00001ea4 + + + +#define NV20_3D_MODELVIEW_MATRIX(i0, i1) (0x00000480 + 0x40*(i0) + 0x4*(i1)) +#define NV20_3D_MODELVIEW_MATRIX__ESIZE 0x00000004 +#define NV20_3D_MODELVIEW_MATRIX__LEN 0x00000010 + +#define NV20_3D_INVERSE_MODELVIEW_MATRIX(i0, i1) (0x00000580 + 0x40*(i0) + 0x4*(i1)) +#define NV20_3D_INVERSE_MODELVIEW_MATRIX__ESIZE 0x00000004 +#define NV20_3D_INVERSE_MODELVIEW_MATRIX__LEN 0x00000010 + +#define NV20_3D_PROJECTION_MATRIX(i0) (0x00000680 + 0x4*(i0)) +#define NV20_3D_PROJECTION_MATRIX__ESIZE 0x00000004 +#define NV20_3D_PROJECTION_MATRIX__LEN 0x00000010 + +#define NV20_3D_VIEWPORT_TRANSLATE 0x00000a20 + + +#define NV20_3D_VIEWPORT_TRANSLATE_X 0x00000a20 + +#define NV20_3D_VIEWPORT_TRANSLATE_Y 0x00000a24 + +#define NV20_3D_VIEWPORT_TRANSLATE_Z 0x00000a28 + +#define NV20_3D_VIEWPORT_TRANSLATE_W 0x00000a2c + +#define NV20_3D_VIEWPORT_SCALE 0x00000af0 + + +#define NV20_3D_VIEWPORT_SCALE_X 0x00000af0 + +#define NV20_3D_VIEWPORT_SCALE_Y 0x00000af4 + +#define NV20_3D_VIEWPORT_SCALE_Z 0x00000af8 + +#define NV20_3D_VIEWPORT_SCALE_W 0x00000afc + + +#define NV20_3D_NORMALIZE_ENABLE 0x000003a4 + +#define NV20_3D_SEPARATE_SPECULAR_ENABLE 0x000003b8 + +#define NV20_3D_LIGHT_MODEL_TWO_SIDE_ENABLE 0x000017c4 + +#define NV20_3D_LIGHT_MODEL 0x00000294 +#define NV20_3D_LIGHT_MODEL_VIEWER__MASK 0x00030000 +#define NV20_3D_LIGHT_MODEL_VIEWER__SHIFT 16 +#define NV20_3D_LIGHT_MODEL_VIEWER_NONLOCAL 0x00020000 +#define NV20_3D_LIGHT_MODEL_VIEWER_LOCAL 0x00030000 +#define NV20_3D_LIGHT_MODEL_SEPARATE_SPECULAR 0x00000001 + +#define NV20_3D_ENABLED_LIGHTS 0x000003bc +#define NV20_3D_ENABLED_LIGHTS_0__MASK 0x00000003 +#define NV20_3D_ENABLED_LIGHTS_0__SHIFT 0 +#define NV20_3D_ENABLED_LIGHTS_0_DISABLED 0x00000000 +#define NV20_3D_ENABLED_LIGHTS_0_NONPOSITIONAL 0x00000001 +#define NV20_3D_ENABLED_LIGHTS_0_POSITIONAL 0x00000002 +#define NV20_3D_ENABLED_LIGHTS_0_DIRECTIONAL 0x00000003 +#define NV20_3D_ENABLED_LIGHTS_1__MASK 0x0000000c +#define NV20_3D_ENABLED_LIGHTS_1__SHIFT 2 +#define NV20_3D_ENABLED_LIGHTS_1_DISABLED 0x00000000 +#define NV20_3D_ENABLED_LIGHTS_1_NONPOSITIONAL 0x00000004 +#define NV20_3D_ENABLED_LIGHTS_1_POSITIONAL 0x00000008 +#define NV20_3D_ENABLED_LIGHTS_1_DIRECTIONAL 0x0000000c +#define NV20_3D_ENABLED_LIGHTS_2__MASK 0x00000030 +#define NV20_3D_ENABLED_LIGHTS_2__SHIFT 4 +#define NV20_3D_ENABLED_LIGHTS_2_DISABLED 0x00000000 +#define NV20_3D_ENABLED_LIGHTS_2_NONPOSITIONAL 0x00000010 +#define NV20_3D_ENABLED_LIGHTS_2_POSITIONAL 0x00000020 +#define NV20_3D_ENABLED_LIGHTS_2_DIRECTIONAL 0x00000030 +#define NV20_3D_ENABLED_LIGHTS_3__MASK 0x000000c0 +#define NV20_3D_ENABLED_LIGHTS_3__SHIFT 6 +#define NV20_3D_ENABLED_LIGHTS_3_DISABLED 0x00000000 +#define NV20_3D_ENABLED_LIGHTS_3_NONPOSITIONAL 0x00000040 +#define NV20_3D_ENABLED_LIGHTS_3_POSITIONAL 0x00000080 +#define NV20_3D_ENABLED_LIGHTS_3_DIRECTIONAL 0x000000c0 +#define NV20_3D_ENABLED_LIGHTS_4__MASK 0x00000300 +#define NV20_3D_ENABLED_LIGHTS_4__SHIFT 8 +#define NV20_3D_ENABLED_LIGHTS_4_DISABLED 0x00000000 +#define NV20_3D_ENABLED_LIGHTS_4_NONPOSITIONAL 0x00000100 +#define NV20_3D_ENABLED_LIGHTS_4_POSITIONAL 0x00000200 +#define NV20_3D_ENABLED_LIGHTS_4_DIRECTIONAL 0x00000300 +#define NV20_3D_ENABLED_LIGHTS_5__MASK 0x00000c00 +#define NV20_3D_ENABLED_LIGHTS_5__SHIFT 10 +#define NV20_3D_ENABLED_LIGHTS_5_DISABLED 0x00000000 +#define NV20_3D_ENABLED_LIGHTS_5_NONPOSITIONAL 0x00000400 +#define NV20_3D_ENABLED_LIGHTS_5_POSITIONAL 0x00000800 +#define NV20_3D_ENABLED_LIGHTS_5_DIRECTIONAL 0x00000c00 +#define NV20_3D_ENABLED_LIGHTS_6__MASK 0x00003000 +#define NV20_3D_ENABLED_LIGHTS_6__SHIFT 12 +#define NV20_3D_ENABLED_LIGHTS_6_DISABLED 0x00000000 +#define NV20_3D_ENABLED_LIGHTS_6_NONPOSITIONAL 0x00001000 +#define NV20_3D_ENABLED_LIGHTS_6_POSITIONAL 0x00002000 +#define NV20_3D_ENABLED_LIGHTS_6_DIRECTIONAL 0x00003000 +#define NV20_3D_ENABLED_LIGHTS_7__MASK 0x0000c000 +#define NV20_3D_ENABLED_LIGHTS_7__SHIFT 14 +#define NV20_3D_ENABLED_LIGHTS_7_DISABLED 0x00000000 +#define NV20_3D_ENABLED_LIGHTS_7_NONPOSITIONAL 0x00004000 +#define NV20_3D_ENABLED_LIGHTS_7_POSITIONAL 0x00008000 +#define NV20_3D_ENABLED_LIGHTS_7_DIRECTIONAL 0x0000c000 + +#define NV20_3D_COLOR_MATERIAL 0x00000298 +#define NV20_3D_COLOR_MATERIAL_FRONT_EMISSION__MASK 0x00000003 +#define NV20_3D_COLOR_MATERIAL_FRONT_EMISSION__SHIFT 0 +#define NV20_3D_COLOR_MATERIAL_FRONT_EMISSION_OFF 0x00000000 +#define NV20_3D_COLOR_MATERIAL_FRONT_EMISSION_COL1 0x00000001 +#define NV20_3D_COLOR_MATERIAL_FRONT_EMISSION_COL2 0x00000002 +#define NV20_3D_COLOR_MATERIAL_FRONT_AMBIENT__MASK 0x0000000c +#define NV20_3D_COLOR_MATERIAL_FRONT_AMBIENT__SHIFT 2 +#define NV20_3D_COLOR_MATERIAL_FRONT_AMBIENT_OFF 0x00000000 +#define NV20_3D_COLOR_MATERIAL_FRONT_AMBIENT_COL1 0x00000004 +#define NV20_3D_COLOR_MATERIAL_FRONT_AMBIENT_COL2 0x00000008 +#define NV20_3D_COLOR_MATERIAL_FRONT_DIFFUSE__MASK 0x00000030 +#define NV20_3D_COLOR_MATERIAL_FRONT_DIFFUSE__SHIFT 4 +#define NV20_3D_COLOR_MATERIAL_FRONT_DIFFUSE_OFF 0x00000000 +#define NV20_3D_COLOR_MATERIAL_FRONT_DIFFUSE_COL1 0x00000010 +#define NV20_3D_COLOR_MATERIAL_FRONT_DIFFUSE_COL2 0x00000020 +#define NV20_3D_COLOR_MATERIAL_FRONT_SPECULAR__MASK 0x000000c0 +#define NV20_3D_COLOR_MATERIAL_FRONT_SPECULAR__SHIFT 6 +#define NV20_3D_COLOR_MATERIAL_FRONT_SPECULAR_OFF 0x00000000 +#define NV20_3D_COLOR_MATERIAL_FRONT_SPECULAR_COL1 0x00000040 +#define NV20_3D_COLOR_MATERIAL_FRONT_SPECULAR_COL2 0x00000080 +#define NV20_3D_COLOR_MATERIAL_BACK_EMISSION__MASK 0x00000300 +#define NV20_3D_COLOR_MATERIAL_BACK_EMISSION__SHIFT 8 +#define NV20_3D_COLOR_MATERIAL_BACK_EMISSION_OFF 0x00000000 +#define NV20_3D_COLOR_MATERIAL_BACK_EMISSION_COL1 0x00000100 +#define NV20_3D_COLOR_MATERIAL_BACK_EMISSION_COL2 0x00000200 +#define NV20_3D_COLOR_MATERIAL_BACK_AMBIENT__MASK 0x00000c00 +#define NV20_3D_COLOR_MATERIAL_BACK_AMBIENT__SHIFT 10 +#define NV20_3D_COLOR_MATERIAL_BACK_AMBIENT_OFF 0x00000000 +#define NV20_3D_COLOR_MATERIAL_BACK_AMBIENT_COL1 0x00000400 +#define NV20_3D_COLOR_MATERIAL_BACK_AMBIENT_COL2 0x00000800 +#define NV20_3D_COLOR_MATERIAL_BACK_DIFFUSE__MASK 0x00003000 +#define NV20_3D_COLOR_MATERIAL_BACK_DIFFUSE__SHIFT 12 +#define NV20_3D_COLOR_MATERIAL_BACK_DIFFUSE_OFF 0x00000000 +#define NV20_3D_COLOR_MATERIAL_BACK_DIFFUSE_COL1 0x00001000 +#define NV20_3D_COLOR_MATERIAL_BACK_DIFFUSE_COL2 0x00002000 +#define NV20_3D_COLOR_MATERIAL_BACK_SPECULAR__MASK 0x0000c000 +#define NV20_3D_COLOR_MATERIAL_BACK_SPECULAR__SHIFT 14 +#define NV20_3D_COLOR_MATERIAL_BACK_SPECULAR_OFF 0x00000000 +#define NV20_3D_COLOR_MATERIAL_BACK_SPECULAR_COL1 0x00004000 +#define NV20_3D_COLOR_MATERIAL_BACK_SPECULAR_COL2 0x00008000 + +#define NV20_3D_MATERIAL_FACTOR_FRONT 0x000003a8 + + +#define NV20_3D_MATERIAL_FACTOR_FRONT_R 0x000003a8 + +#define NV20_3D_MATERIAL_FACTOR_FRONT_G 0x000003ac + +#define NV20_3D_MATERIAL_FACTOR_FRONT_B 0x000003b0 + +#define NV20_3D_MATERIAL_FACTOR_BACK 0x000017b0 + + +#define NV20_3D_MATERIAL_FACTOR_BACK_R 0x000017b0 + +#define NV20_3D_MATERIAL_FACTOR_BACK_G 0x000017b4 + +#define NV20_3D_MATERIAL_FACTOR_BACK_B 0x000017b8 + +#define NV20_3D_MATERIAL_FACTOR_FRONT_A 0x000003b4 + +#define NV20_3D_MATERIAL_FACTOR_BACK_A 0x000017ac + +#define NV20_3D_LIGHT_MODEL_FRONT_AMBIENT 0x00000a10 + + +#define NV20_3D_LIGHT_MODEL_FRONT_AMBIENT_R 0x00000a10 + +#define NV20_3D_LIGHT_MODEL_FRONT_AMBIENT_G 0x00000a14 + +#define NV20_3D_LIGHT_MODEL_FRONT_AMBIENT_B 0x00000a18 + +#define NV20_3D_LIGHT_MODEL_BACK_AMBIENT 0x000017a0 + + +#define NV20_3D_LIGHT_MODEL_BACK_AMBIENT_R 0x000017a0 + +#define NV20_3D_LIGHT_MODEL_BACK_AMBIENT_G 0x000017a4 + +#define NV20_3D_LIGHT_MODEL_BACK_AMBIENT_B 0x000017a8 + +#define NV20_3D_FRONT_MATERIAL_SHININESS(i0) (0x000009e0 + 0x4*(i0)) +#define NV20_3D_FRONT_MATERIAL_SHININESS__ESIZE 0x00000004 +#define NV20_3D_FRONT_MATERIAL_SHININESS__LEN 0x00000006 + +#define NV20_3D_BACK_MATERIAL_SHININESS(i0) (0x00001e28 + 0x4*(i0)) +#define NV20_3D_BACK_MATERIAL_SHININESS__ESIZE 0x00000004 +#define NV20_3D_BACK_MATERIAL_SHININESS__LEN 0x00000006 + + + +#define NV20_3D_LIGHT_FRONT_AMBIENT(i0) (0x00001000 + 0x80*(i0)) + + +#define NV20_3D_LIGHT_FRONT_AMBIENT_R(i0) (0x00001000 + 0x80*(i0)) + +#define NV20_3D_LIGHT_FRONT_AMBIENT_G(i0) (0x00001004 + 0x80*(i0)) + +#define NV20_3D_LIGHT_FRONT_AMBIENT_B(i0) (0x00001008 + 0x80*(i0)) + +#define NV20_3D_LIGHT_FRONT_DIFFUSE(i0) (0x0000100c + 0x80*(i0)) + + +#define NV20_3D_LIGHT_FRONT_DIFFUSE_R(i0) (0x0000100c + 0x80*(i0)) + +#define NV20_3D_LIGHT_FRONT_DIFFUSE_G(i0) (0x00001010 + 0x80*(i0)) + +#define NV20_3D_LIGHT_FRONT_DIFFUSE_B(i0) (0x00001014 + 0x80*(i0)) + +#define NV20_3D_LIGHT_FRONT_SPECULAR(i0) (0x00001018 + 0x80*(i0)) + + +#define NV20_3D_LIGHT_FRONT_SPECULAR_R(i0) (0x00001018 + 0x80*(i0)) + +#define NV20_3D_LIGHT_FRONT_SPECULAR_G(i0) (0x0000101c + 0x80*(i0)) + +#define NV20_3D_LIGHT_FRONT_SPECULAR_B(i0) (0x00001020 + 0x80*(i0)) + + +#define NV20_3D_LIGHT_BACK_AMBIENT(i0) (0x00000c00 + 0x40*(i0)) + + +#define NV20_3D_LIGHT_BACK_AMBIENT_R(i0) (0x00000c00 + 0x40*(i0)) + +#define NV20_3D_LIGHT_BACK_AMBIENT_G(i0) (0x00000c04 + 0x40*(i0)) + +#define NV20_3D_LIGHT_BACK_AMBIENT_B(i0) (0x00000c08 + 0x40*(i0)) + +#define NV20_3D_LIGHT_BACK_DIFFUSE(i0) (0x00000c0c + 0x40*(i0)) + + +#define NV20_3D_LIGHT_BACK_DIFFUSE_R(i0) (0x00000c0c + 0x40*(i0)) + +#define NV20_3D_LIGHT_BACK_DIFFUSE_G(i0) (0x00000c10 + 0x40*(i0)) + +#define NV20_3D_LIGHT_BACK_DIFFUSE_B(i0) (0x00000c14 + 0x40*(i0)) + +#define NV20_3D_LIGHT_BACK_SPECULAR(i0) (0x00000c18 + 0x40*(i0)) + + +#define NV20_3D_LIGHT_BACK_SPECULAR_R(i0) (0x00000c18 + 0x40*(i0)) + +#define NV20_3D_LIGHT_BACK_SPECULAR_G(i0) (0x00000c1c + 0x40*(i0)) + +#define NV20_3D_LIGHT_BACK_SPECULAR_B(i0) (0x00000c20 + 0x40*(i0)) + + +#define NV20_3D_LIGHT_HALF_VECTOR(i0) (0x00001028 + 0x80*(i0)) + + +#define NV20_3D_LIGHT_HALF_VECTOR_X(i0) (0x00001028 + 0x80*(i0)) + +#define NV20_3D_LIGHT_HALF_VECTOR_Y(i0) (0x0000102c + 0x80*(i0)) + +#define NV20_3D_LIGHT_HALF_VECTOR_Z(i0) (0x00001030 + 0x80*(i0)) + +#define NV20_3D_LIGHT_DIRECTION(i0) (0x00001034 + 0x80*(i0)) + + +#define NV20_3D_LIGHT_DIRECTION_X(i0) (0x00001034 + 0x80*(i0)) + +#define NV20_3D_LIGHT_DIRECTION_Y(i0) (0x00001038 + 0x80*(i0)) + +#define NV20_3D_LIGHT_DIRECTION_Z(i0) (0x0000103c + 0x80*(i0)) + +#define NV20_3D_LIGHT_SPOT_CUTOFF(i0, i1) (0x00001040 + 0x80*(i0) + 0x4*(i1)) +#define NV20_3D_LIGHT_SPOT_CUTOFF__ESIZE 0x00000004 +#define NV20_3D_LIGHT_SPOT_CUTOFF__LEN 0x00000007 + +#define NV20_3D_LIGHT_POSITION(i0) (0x0000105c + 0x80*(i0)) + + +#define NV20_3D_LIGHT_POSITION_X(i0) (0x0000105c + 0x80*(i0)) + +#define NV20_3D_LIGHT_POSITION_Y(i0) (0x00001060 + 0x80*(i0)) + +#define NV20_3D_LIGHT_POSITION_Z(i0) (0x00001064 + 0x80*(i0)) + +#define NV20_3D_LIGHT_ATTENUATION(i0) (0x00001068 + 0x80*(i0)) + +#define NV20_3D_LIGHT_ATTENUATION_CONSTANT(i0) (0x00001068 + 0x80*(i0)) + +#define NV20_3D_LIGHT_ATTENUATION_LINEAR(i0) (0x0000106c + 0x80*(i0)) + +#define NV20_3D_LIGHT_ATTENUATION_QUADRATIC(i0) (0x00001070 + 0x80*(i0)) + + +#define NV20_3D_FOG_MODE 0x0000029c +#define NV20_3D_FOG_MODE_LINEAR_UNSIGNED 0x00000804 +#define NV20_3D_FOG_MODE_LINEAR_SIGNED 0x00002601 +#define NV20_3D_FOG_MODE_EXP_UNSIGNED 0x00000802 +#define NV20_3D_FOG_MODE_EXP_SIGNED 0x00000800 +#define NV20_3D_FOG_MODE_EXP2_UNSIGNED 0x00000803 +#define NV20_3D_FOG_MODE_EXP2_SIGNED 0x00000801 + +#define NV20_3D_FOG_COORD 0x000002a0 +#define NV20_3D_FOG_COORD_DIST_RADIAL 0x00000001 +#define NV20_3D_FOG_COORD_DIST_ORTHOGONAL 0x00000002 +#define NV20_3D_FOG_COORD_DIST_ORTHOGONAL_ABS 0x00000003 +#define NV20_3D_FOG_COORD_FOG 0x00000006 + +#define NV20_3D_FOG_ENABLE 0x000002a4 + +#define NV20_3D_FOG_COLOR 0x000002a8 +#define NV20_3D_FOG_COLOR_R__MASK 0x000000ff +#define NV20_3D_FOG_COLOR_R__SHIFT 0 +#define NV20_3D_FOG_COLOR_G__MASK 0x0000ff00 +#define NV20_3D_FOG_COLOR_G__SHIFT 8 +#define NV20_3D_FOG_COLOR_B__MASK 0x00ff0000 +#define NV20_3D_FOG_COLOR_B__SHIFT 16 +#define NV20_3D_FOG_COLOR_A__MASK 0xff000000 +#define NV20_3D_FOG_COLOR_A__SHIFT 24 + +#define NV20_3D_FOG_COEFF(i0) (0x000009c0 + 0x4*(i0)) +#define NV20_3D_FOG_COEFF__ESIZE 0x00000004 +#define NV20_3D_FOG_COEFF__LEN 0x00000003 + + + +#define NV20_3D_TEX_GEN_MODE(i0, i1) (0x000003c0 + 0x10*(i0) + 0x4*(i1)) +#define NV20_3D_TEX_GEN_MODE__ESIZE 0x00000004 +#define NV20_3D_TEX_GEN_MODE__LEN 0x00000004 +#define NV20_3D_TEX_GEN_MODE_FALSE 0x00000000 +#define NV20_3D_TEX_GEN_MODE_EYE_LINEAR 0x00002400 +#define NV20_3D_TEX_GEN_MODE_OBJECT_LINEAR 0x00002401 +#define NV20_3D_TEX_GEN_MODE_SPHERE_MAP 0x00002402 +#define NV20_3D_TEX_GEN_MODE_NORMAL_MAP 0x00008511 +#define NV20_3D_TEX_GEN_MODE_REFLECTION_MAP 0x00008512 + + +#define NV20_3D_TEX_GEN_COEFF(i0, i1) (0x00000840 + 0x40*(i0) + 0x10*(i1)) +#define NV20_3D_TEX_GEN_COEFF__ESIZE 0x00000010 +#define NV20_3D_TEX_GEN_COEFF__LEN 0x00000004 + +#define NV20_3D_TEX_GEN_COEFF_A(i0, i1) (0x00000840 + 0x40*(i0) + 0x10*(i1)) + +#define NV20_3D_TEX_GEN_COEFF_B(i0, i1) (0x00000844 + 0x40*(i0) + 0x10*(i1)) + +#define NV20_3D_TEX_GEN_COEFF_C(i0, i1) (0x00000848 + 0x40*(i0) + 0x10*(i1)) + +#define NV20_3D_TEX_GEN_COEFF_D(i0, i1) (0x0000084c + 0x40*(i0) + 0x10*(i1)) + +#define NV20_3D_TEX_MATRIX_ENABLE(i0) (0x00000420 + 0x4*(i0)) +#define NV20_3D_TEX_MATRIX_ENABLE__ESIZE 0x00000004 +#define NV20_3D_TEX_MATRIX_ENABLE__LEN 0x00000004 + + +#define NV20_3D_TEX_MATRIX(i0, i1) (0x000006c0 + 0x40*(i0) + 0x4*(i1)) +#define NV20_3D_TEX_MATRIX__ESIZE 0x00000004 +#define NV20_3D_TEX_MATRIX__LEN 0x00000010 + +#define NV20_3D_TEX_SHADER_CULL_MODE 0x000017f8 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_S__MASK 0x00000001 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_S__SHIFT 0 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_S_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_S_LESS 0x00000001 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_T__MASK 0x00000002 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_T__SHIFT 1 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_T_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_T_LESS 0x00000002 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_R__MASK 0x00000004 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_R__SHIFT 2 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_R_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_R_LESS 0x00000004 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_Q__MASK 0x00000008 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_Q__SHIFT 3 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_Q_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX0_Q_LESS 0x00000008 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_S__MASK 0x00000010 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_S__SHIFT 4 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_S_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_S_LESS 0x00000010 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_T__MASK 0x00000020 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_T__SHIFT 5 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_T_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_T_LESS 0x00000020 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_R__MASK 0x00000040 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_R__SHIFT 6 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_R_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_R_LESS 0x00000040 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_Q__MASK 0x00000080 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_Q__SHIFT 7 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_Q_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX1_Q_LESS 0x00000080 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_S__MASK 0x00000100 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_S__SHIFT 8 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_S_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_S_LESS 0x00000100 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_T__MASK 0x00000200 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_T__SHIFT 9 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_T_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_T_LESS 0x00000200 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_R__MASK 0x00000400 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_R__SHIFT 10 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_R_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_R_LESS 0x00000400 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_Q__MASK 0x00000800 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_Q__SHIFT 11 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_Q_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX2_Q_LESS 0x00000800 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_S__MASK 0x00001000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_S__SHIFT 12 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_S_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_S_LESS 0x00001000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_T__MASK 0x00002000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_T__SHIFT 13 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_T_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_T_LESS 0x00002000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_R__MASK 0x00004000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_R__SHIFT 14 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_R_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_R_LESS 0x00004000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_Q__MASK 0x00008000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_Q__SHIFT 15 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_Q_GEQUAL 0x00000000 +#define NV20_3D_TEX_SHADER_CULL_MODE_TX3_Q_LESS 0x00008000 + +#define NV20_3D_TEX_SHADER_CONST_EYE 0x0000181c + + +#define NV20_3D_TEX_SHADER_CONST_EYE_X 0x0000181c + +#define NV20_3D_TEX_SHADER_CONST_EYE_Y 0x00001820 + +#define NV20_3D_TEX_SHADER_CONST_EYE_Z 0x00001824 + + +#define NV20_3D_TEX_SHADER_OFFSET_MATRIX(i0, i1) (0x00001b28 + 0x40*(i0) + 0x4*(i1)) +#define NV20_3D_TEX_SHADER_OFFSET_MATRIX__ESIZE 0x00000004 +#define NV20_3D_TEX_SHADER_OFFSET_MATRIX__LEN 0x00000004 + +#define NV20_3D_TEX_RCOMP 0x00001e6c +#define NV20_3D_TEX_RCOMP_NEVER 0x00000000 +#define NV20_3D_TEX_RCOMP_GREATER 0x00000001 +#define NV20_3D_TEX_RCOMP_EQUAL 0x00000002 +#define NV20_3D_TEX_RCOMP_GEQUAL 0x00000003 +#define NV20_3D_TEX_RCOMP_LESS 0x00000004 +#define NV20_3D_TEX_RCOMP_NOTEQUAL 0x00000005 +#define NV20_3D_TEX_RCOMP_LEQUAL 0x00000006 +#define NV20_3D_TEX_RCOMP_ALWAYS 0x00000007 + +#define NV20_3D_TEX_SHADER_OP 0x00001e70 +#define NV20_3D_TEX_SHADER_OP_TX0__MASK 0x0000001f +#define NV20_3D_TEX_SHADER_OP_TX0__SHIFT 0 +#define NV20_3D_TEX_SHADER_OP_TX0_NONE 0x00000000 +#define NV20_3D_TEX_SHADER_OP_TX0_TEXTURE_2D 0x00000001 +#define NV20_3D_TEX_SHADER_OP_TX0_PASS_THROUGH 0x00000004 +#define NV20_3D_TEX_SHADER_OP_TX0_CULL_FRAGMENT 0x00000005 +#define NV20_3D_TEX_SHADER_OP_TX0_OFFSET_TEXTURE_2D 0x00000006 +#define NV20_3D_TEX_SHADER_OP_TX0_DOT_PRODUCT_TEXTURE_2D 0x00000009 +#define NV20_3D_TEX_SHADER_OP_TX0_DOT_PRODUCT_DEPTH_REPLACE 0x0000000a +#define NV20_3D_TEX_SHADER_OP_TX0_DEPENDANT_AR_TEXTURE_2D 0x0000000f +#define NV20_3D_TEX_SHADER_OP_TX0_DEPENDANT_GB_TEXTURE_2D 0x00000010 +#define NV20_3D_TEX_SHADER_OP_TX0_DOT_PRODUCT 0x00000011 +#define NV20_3D_TEX_SHADER_OP_TX1__MASK 0x000003e0 +#define NV20_3D_TEX_SHADER_OP_TX1__SHIFT 5 +#define NV20_3D_TEX_SHADER_OP_TX1_NONE 0x00000000 +#define NV20_3D_TEX_SHADER_OP_TX1_TEXTURE_2D 0x00000020 +#define NV20_3D_TEX_SHADER_OP_TX1_PASS_THROUGH 0x00000080 +#define NV20_3D_TEX_SHADER_OP_TX1_CULL_FRAGMENT 0x000000a0 +#define NV20_3D_TEX_SHADER_OP_TX1_OFFSET_TEXTURE_2D 0x000000c0 +#define NV20_3D_TEX_SHADER_OP_TX1_DOT_PRODUCT_TEXTURE_2D 0x00000120 +#define NV20_3D_TEX_SHADER_OP_TX1_DOT_PRODUCT_DEPTH_REPLACE 0x00000140 +#define NV20_3D_TEX_SHADER_OP_TX1_DEPENDANT_AR_TEXTURE_2D 0x000001e0 +#define NV20_3D_TEX_SHADER_OP_TX1_DEPENDANT_GB_TEXTURE_2D 0x00000200 +#define NV20_3D_TEX_SHADER_OP_TX1_DOT_PRODUCT 0x00000220 +#define NV20_3D_TEX_SHADER_OP_TX2__MASK 0x00007c00 +#define NV20_3D_TEX_SHADER_OP_TX2__SHIFT 10 +#define NV20_3D_TEX_SHADER_OP_TX2_NONE 0x00000000 +#define NV20_3D_TEX_SHADER_OP_TX2_TEXTURE_2D 0x00000400 +#define NV20_3D_TEX_SHADER_OP_TX2_PASS_THROUGH 0x00001000 +#define NV20_3D_TEX_SHADER_OP_TX2_CULL_FRAGMENT 0x00001400 +#define NV20_3D_TEX_SHADER_OP_TX2_OFFSET_TEXTURE_2D 0x00001800 +#define NV20_3D_TEX_SHADER_OP_TX2_DOT_PRODUCT_TEXTURE_2D 0x00002400 +#define NV20_3D_TEX_SHADER_OP_TX2_DOT_PRODUCT_DEPTH_REPLACE 0x00002800 +#define NV20_3D_TEX_SHADER_OP_TX2_DEPENDANT_AR_TEXTURE_2D 0x00003c00 +#define NV20_3D_TEX_SHADER_OP_TX2_DEPENDANT_GB_TEXTURE_2D 0x00004000 +#define NV20_3D_TEX_SHADER_OP_TX2_DOT_PRODUCT 0x00004400 +#define NV20_3D_TEX_SHADER_OP_TX3__MASK 0x000f8000 +#define NV20_3D_TEX_SHADER_OP_TX3__SHIFT 15 +#define NV20_3D_TEX_SHADER_OP_TX3_NONE 0x00000000 +#define NV20_3D_TEX_SHADER_OP_TX3_TEXTURE_2D 0x00008000 +#define NV20_3D_TEX_SHADER_OP_TX3_PASS_THROUGH 0x00020000 +#define NV20_3D_TEX_SHADER_OP_TX3_CULL_FRAGMENT 0x00028000 +#define NV20_3D_TEX_SHADER_OP_TX3_OFFSET_TEXTURE_2D 0x00030000 +#define NV20_3D_TEX_SHADER_OP_TX3_DOT_PRODUCT_TEXTURE_2D 0x00048000 +#define NV20_3D_TEX_SHADER_OP_TX3_DOT_PRODUCT_DEPTH_REPLACE 0x00050000 +#define NV20_3D_TEX_SHADER_OP_TX3_DEPENDANT_AR_TEXTURE_2D 0x00078000 +#define NV20_3D_TEX_SHADER_OP_TX3_DEPENDANT_GB_TEXTURE_2D 0x00080000 +#define NV20_3D_TEX_SHADER_OP_TX3_DOT_PRODUCT 0x00088000 + +#define NV20_3D_TEX_SHADER_DOTMAPPING 0x00001e74 +#define NV20_3D_TEX_SHADER_DOTMAPPING_TX0__MASK 0x0000000f +#define NV20_3D_TEX_SHADER_DOTMAPPING_TX0__SHIFT 0 +#define NV20_3D_TEX_SHADER_DOTMAPPING_TX1__MASK 0x000000f0 +#define NV20_3D_TEX_SHADER_DOTMAPPING_TX1__SHIFT 4 +#define NV20_3D_TEX_SHADER_DOTMAPPING_TX2__MASK 0x00000f00 +#define NV20_3D_TEX_SHADER_DOTMAPPING_TX2__SHIFT 8 +#define NV20_3D_TEX_SHADER_DOTMAPPING_TX3__MASK 0x0000f000 +#define NV20_3D_TEX_SHADER_DOTMAPPING_TX3__SHIFT 12 + +#define NV20_3D_TEX_SHADER_PREVIOUS 0x00001e78 +#define NV20_3D_TEX_SHADER_PREVIOUS_TX0__MASK 0x00000f00 +#define NV20_3D_TEX_SHADER_PREVIOUS_TX0__SHIFT 8 +#define NV20_3D_TEX_SHADER_PREVIOUS_TX1__MASK 0x0000f000 +#define NV20_3D_TEX_SHADER_PREVIOUS_TX1__SHIFT 12 +#define NV20_3D_TEX_SHADER_PREVIOUS_TX2__MASK 0x00030000 +#define NV20_3D_TEX_SHADER_PREVIOUS_TX2__SHIFT 16 +#define NV20_3D_TEX_SHADER_PREVIOUS_TX3__MASK 0x00300000 +#define NV20_3D_TEX_SHADER_PREVIOUS_TX3__SHIFT 20 + +#define NV20_3D_TEX(i0) (0x00000000 + 0x40*(i0)) +#define NV20_3D_TEX__ESIZE 0x00000040 +#define NV20_3D_TEX__LEN 0x00000004 + +#define NV20_3D_TEX_OFFSET(i0) (0x00001b00 + 0x40*(i0)) + +#define NV20_3D_TEX_FORMAT(i0) (0x00001b04 + 0x40*(i0)) +#define NV20_3D_TEX_FORMAT_DMA0 0x00000001 +#define NV20_3D_TEX_FORMAT_DMA1 0x00000002 +#define NV20_3D_TEX_FORMAT_CUBIC 0x00000004 +#define NV20_3D_TEX_FORMAT_NO_BORDER 0x00000008 +#define NV20_3D_TEX_FORMAT_DIMS__MASK 0x000000f0 +#define NV20_3D_TEX_FORMAT_DIMS__SHIFT 4 +#define NV20_3D_TEX_FORMAT_DIMS_1D 0x00000010 +#define NV20_3D_TEX_FORMAT_DIMS_2D 0x00000020 +#define NV20_3D_TEX_FORMAT_DIMS_3D 0x00000030 +#define NV20_3D_TEX_FORMAT_FORMAT__MASK 0x0000ff00 +#define NV20_3D_TEX_FORMAT_FORMAT__SHIFT 8 +#define NV20_3D_TEX_FORMAT_FORMAT_L8 0x00000000 +#define NV20_3D_TEX_FORMAT_FORMAT_I8 0x00000100 +#define NV20_3D_TEX_FORMAT_FORMAT_A1R5G5B5 0x00000200 +#define NV20_3D_TEX_FORMAT_FORMAT_A4R4G4B4 0x00000400 +#define NV20_3D_TEX_FORMAT_FORMAT_R5G6B5 0x00000500 +#define NV20_3D_TEX_FORMAT_FORMAT_A8R8G8B8 0x00000600 +#define NV20_3D_TEX_FORMAT_FORMAT_X8R8G8B8 0x00000700 +#define NV20_3D_TEX_FORMAT_FORMAT_INDEX8 0x00000b00 +#define NV20_3D_TEX_FORMAT_FORMAT_DXT1 0x00000c00 +#define NV20_3D_TEX_FORMAT_FORMAT_DXT3 0x00000e00 +#define NV20_3D_TEX_FORMAT_FORMAT_DXT5 0x00000f00 +#define NV20_3D_TEX_FORMAT_FORMAT_A1R5G5B5_RECT 0x00001000 +#define NV20_3D_TEX_FORMAT_FORMAT_R5G6B5_RECT 0x00001100 +#define NV20_3D_TEX_FORMAT_FORMAT_A8R8G8B8_RECT 0x00001200 +#define NV20_3D_TEX_FORMAT_FORMAT_L8_RECT 0x00001300 +#define NV20_3D_TEX_FORMAT_FORMAT_DSDT8_RECT 0x00001700 +#define NV20_3D_TEX_FORMAT_FORMAT_A8L8 0x00001a00 +#define NV20_3D_TEX_FORMAT_FORMAT_I8_RECT 0x00001b00 +#define NV20_3D_TEX_FORMAT_FORMAT_A4R4G4B4_RECT 0x00001d00 +#define NV20_3D_TEX_FORMAT_FORMAT_R8G8B8_RECT 0x00001e00 +#define NV20_3D_TEX_FORMAT_FORMAT_A8L8_RECT 0x00002000 +#define NV20_3D_TEX_FORMAT_FORMAT_Z24 0x00002a00 +#define NV20_3D_TEX_FORMAT_FORMAT_Z24_RECT 0x00002b00 +#define NV20_3D_TEX_FORMAT_FORMAT_Z16 0x00002c00 +#define NV20_3D_TEX_FORMAT_FORMAT_Z16_RECT 0x00002d00 +#define NV20_3D_TEX_FORMAT_FORMAT_DSDT8 0x00002800 +#define NV20_3D_TEX_FORMAT_FORMAT_HILO16 0x00003300 +#define NV20_3D_TEX_FORMAT_FORMAT_HILO16_RECT 0x00003600 +#define NV20_3D_TEX_FORMAT_FORMAT_HILO8 0x00004400 +#define NV20_3D_TEX_FORMAT_FORMAT_SIGNED_HILO8 0x00004500 +#define NV20_3D_TEX_FORMAT_FORMAT_HILO8_RECT 0x00004600 +#define NV20_3D_TEX_FORMAT_FORMAT_SIGNED_HILO8_RECT 0x00004700 +#define NV20_3D_TEX_FORMAT_MIPMAP 0x00080000 +#define NV20_3D_TEX_FORMAT_BASE_SIZE_U__MASK 0x00f00000 +#define NV20_3D_TEX_FORMAT_BASE_SIZE_U__SHIFT 20 +#define NV20_3D_TEX_FORMAT_BASE_SIZE_V__MASK 0x0f000000 +#define NV20_3D_TEX_FORMAT_BASE_SIZE_V__SHIFT 24 +#define NV20_3D_TEX_FORMAT_BASE_SIZE_W__MASK 0xf0000000 +#define NV20_3D_TEX_FORMAT_BASE_SIZE_W__SHIFT 28 + +#define NV20_3D_TEX_WRAP(i0) (0x00001b08 + 0x40*(i0)) +#define NV20_3D_TEX_WRAP_S__MASK 0x000000ff +#define NV20_3D_TEX_WRAP_S__SHIFT 0 +#define NV20_3D_TEX_WRAP_S_REPEAT 0x00000001 +#define NV20_3D_TEX_WRAP_S_MIRRORED_REPEAT 0x00000002 +#define NV20_3D_TEX_WRAP_S_CLAMP_TO_EDGE 0x00000003 +#define NV20_3D_TEX_WRAP_S_CLAMP_TO_BORDER 0x00000004 +#define NV20_3D_TEX_WRAP_S_CLAMP 0x00000005 +#define NV20_3D_TEX_WRAP_T__MASK 0x00000f00 +#define NV20_3D_TEX_WRAP_T__SHIFT 8 +#define NV20_3D_TEX_WRAP_T_REPEAT 0x00000100 +#define NV20_3D_TEX_WRAP_T_MIRRORED_REPEAT 0x00000200 +#define NV20_3D_TEX_WRAP_T_CLAMP_TO_EDGE 0x00000300 +#define NV20_3D_TEX_WRAP_T_CLAMP_TO_BORDER 0x00000400 +#define NV20_3D_TEX_WRAP_T_CLAMP 0x00000500 +#define NV20_3D_TEX_WRAP_R__MASK 0x000f0000 +#define NV20_3D_TEX_WRAP_R__SHIFT 16 +#define NV20_3D_TEX_WRAP_R_REPEAT 0x00010000 +#define NV20_3D_TEX_WRAP_R_MIRRORED_REPEAT 0x00020000 +#define NV20_3D_TEX_WRAP_R_CLAMP_TO_EDGE 0x00030000 +#define NV20_3D_TEX_WRAP_R_CLAMP_TO_BORDER 0x00040000 +#define NV20_3D_TEX_WRAP_R_CLAMP 0x00050000 + +#define NV20_3D_TEX_ENABLE(i0) (0x00001b0c + 0x40*(i0)) +#define NV20_3D_TEX_ENABLE_ANISO__MASK 0x00000030 +#define NV20_3D_TEX_ENABLE_ANISO__SHIFT 4 +#define NV20_3D_TEX_ENABLE_ANISO_NONE 0x00000000 +#define NV20_3D_TEX_ENABLE_ANISO_2X 0x00000010 +#define NV20_3D_TEX_ENABLE_ANISO_4X 0x00000020 +#define NV20_3D_TEX_ENABLE_ANISO_8X 0x00000030 +#define NV20_3D_TEX_ENABLE_MIPMAP_MAX_LOD__MASK 0x0003c000 +#define NV20_3D_TEX_ENABLE_MIPMAP_MAX_LOD__SHIFT 14 +#define NV20_3D_TEX_ENABLE_MIPMAP_MIN_LOD__MASK 0x3c000000 +#define NV20_3D_TEX_ENABLE_MIPMAP_MIN_LOD__SHIFT 26 +#define NV20_3D_TEX_ENABLE_ENABLE 0x40000000 + +#define NV20_3D_TEX_NPOT_PITCH(i0) (0x00001b10 + 0x40*(i0)) +#define NV20_3D_TEX_NPOT_PITCH_PITCH__MASK 0xffff0000 +#define NV20_3D_TEX_NPOT_PITCH_PITCH__SHIFT 16 + +#define NV20_3D_TEX_FILTER(i0) (0x00001b14 + 0x40*(i0)) +#define NV20_3D_TEX_FILTER_LOD_BIAS__MASK 0x00000f00 +#define NV20_3D_TEX_FILTER_LOD_BIAS__SHIFT 8 +#define NV20_3D_TEX_FILTER_MINIFY__MASK 0x000f0000 +#define NV20_3D_TEX_FILTER_MINIFY__SHIFT 16 +#define NV20_3D_TEX_FILTER_MINIFY_NEAREST 0x00010000 +#define NV20_3D_TEX_FILTER_MINIFY_LINEAR 0x00020000 +#define NV20_3D_TEX_FILTER_MINIFY_NEAREST_MIPMAP_NEAREST 0x00030000 +#define NV20_3D_TEX_FILTER_MINIFY_LINEAR_MIPMAP_NEAREST 0x00040000 +#define NV20_3D_TEX_FILTER_MINIFY_NEAREST_MIPMAP_LINEAR 0x00050000 +#define NV20_3D_TEX_FILTER_MINIFY_LINEAR_MIPMAP_LINEAR 0x00060000 +#define NV20_3D_TEX_FILTER_MAGNIFY__MASK 0x0f000000 +#define NV20_3D_TEX_FILTER_MAGNIFY__SHIFT 24 +#define NV20_3D_TEX_FILTER_MAGNIFY_NEAREST 0x01000000 +#define NV20_3D_TEX_FILTER_MAGNIFY_LINEAR 0x02000000 + +#define NV20_3D_TEX_NPOT_SIZE(i0) (0x00001b1c + 0x40*(i0)) +#define NV20_3D_TEX_NPOT_SIZE_H__MASK 0x0000ffff +#define NV20_3D_TEX_NPOT_SIZE_H__SHIFT 0 +#define NV20_3D_TEX_NPOT_SIZE_W__MASK 0xffff0000 +#define NV20_3D_TEX_NPOT_SIZE_W__SHIFT 16 + +#define NV20_3D_TEX_PALETTE_OFFSET(i0) (0x00001b20 + 0x40*(i0)) + +#define NV20_3D_TEX_BORDER_COLOR(i0) (0x00001b24 + 0x40*(i0)) +#define NV20_3D_TEX_BORDER_COLOR_B__MASK 0x000000ff +#define NV20_3D_TEX_BORDER_COLOR_B__SHIFT 0 +#define NV20_3D_TEX_BORDER_COLOR_G__MASK 0x0000ff00 +#define NV20_3D_TEX_BORDER_COLOR_G__SHIFT 8 +#define NV20_3D_TEX_BORDER_COLOR_R__MASK 0x00ff0000 +#define NV20_3D_TEX_BORDER_COLOR_R__SHIFT 16 +#define NV20_3D_TEX_BORDER_COLOR_A__MASK 0xff000000 +#define NV20_3D_TEX_BORDER_COLOR_A__SHIFT 24 + + + +#define NV20_3D_RC_IN_ALPHA(i0) (0x00000260 + 0x4*(i0)) +#define NV20_3D_RC_IN_ALPHA_D_INPUT__MASK 0x0000000f +#define NV20_3D_RC_IN_ALPHA_D_INPUT__SHIFT 0 +#define NV20_3D_RC_IN_ALPHA_D_INPUT_ZERO 0x00000000 +#define NV20_3D_RC_IN_ALPHA_D_INPUT_CONSTANT_COLOR0 0x00000001 +#define NV20_3D_RC_IN_ALPHA_D_INPUT_CONSTANT_COLOR1 0x00000002 +#define NV20_3D_RC_IN_ALPHA_D_INPUT_FOG 0x00000003 +#define NV20_3D_RC_IN_ALPHA_D_INPUT_PRIMARY_COLOR 0x00000004 +#define NV20_3D_RC_IN_ALPHA_D_INPUT_SECONDARY_COLOR 0x00000005 +#define NV20_3D_RC_IN_ALPHA_D_INPUT_TEXTURE0 0x00000008 +#define NV20_3D_RC_IN_ALPHA_D_INPUT_TEXTURE1 0x00000009 +#define NV20_3D_RC_IN_ALPHA_D_INPUT_TEXTURE2 0x0000000a +#define NV20_3D_RC_IN_ALPHA_D_INPUT_TEXTURE3 0x0000000b +#define NV20_3D_RC_IN_ALPHA_D_INPUT_SPARE0 0x0000000c +#define NV20_3D_RC_IN_ALPHA_D_INPUT_SPARE1 0x0000000d +#define NV20_3D_RC_IN_ALPHA_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e +#define NV20_3D_RC_IN_ALPHA_D_INPUT_E_TIMES_F 0x0000000f +#define NV20_3D_RC_IN_ALPHA_D_COMPONENT_USAGE__MASK 0x00000010 +#define NV20_3D_RC_IN_ALPHA_D_COMPONENT_USAGE__SHIFT 4 +#define NV20_3D_RC_IN_ALPHA_D_COMPONENT_USAGE_BLUE 0x00000000 +#define NV20_3D_RC_IN_ALPHA_D_COMPONENT_USAGE_ALPHA 0x00000010 +#define NV20_3D_RC_IN_ALPHA_D_MAPPING__MASK 0x000000e0 +#define NV20_3D_RC_IN_ALPHA_D_MAPPING__SHIFT 5 +#define NV20_3D_RC_IN_ALPHA_D_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV20_3D_RC_IN_ALPHA_D_MAPPING_UNSIGNED_INVERT 0x00000020 +#define NV20_3D_RC_IN_ALPHA_D_MAPPING_EXPAND_NORMAL 0x00000040 +#define NV20_3D_RC_IN_ALPHA_D_MAPPING_EXPAND_NEGATE 0x00000060 +#define NV20_3D_RC_IN_ALPHA_D_MAPPING_HALF_BIAS_NORMAL 0x00000080 +#define NV20_3D_RC_IN_ALPHA_D_MAPPING_HALF_BIAS_NEGATE 0x000000a0 +#define NV20_3D_RC_IN_ALPHA_D_MAPPING_SIGNED_IDENTITY 0x000000c0 +#define NV20_3D_RC_IN_ALPHA_D_MAPPING_SIGNED_NEGATE 0x000000e0 +#define NV20_3D_RC_IN_ALPHA_C_INPUT__MASK 0x00000f00 +#define NV20_3D_RC_IN_ALPHA_C_INPUT__SHIFT 8 +#define NV20_3D_RC_IN_ALPHA_C_INPUT_ZERO 0x00000000 +#define NV20_3D_RC_IN_ALPHA_C_INPUT_CONSTANT_COLOR0 0x00000100 +#define NV20_3D_RC_IN_ALPHA_C_INPUT_CONSTANT_COLOR1 0x00000200 +#define NV20_3D_RC_IN_ALPHA_C_INPUT_FOG 0x00000300 +#define NV20_3D_RC_IN_ALPHA_C_INPUT_PRIMARY_COLOR 0x00000400 +#define NV20_3D_RC_IN_ALPHA_C_INPUT_SECONDARY_COLOR 0x00000500 +#define NV20_3D_RC_IN_ALPHA_C_INPUT_TEXTURE0 0x00000800 +#define NV20_3D_RC_IN_ALPHA_C_INPUT_TEXTURE1 0x00000900 +#define NV20_3D_RC_IN_ALPHA_C_INPUT_TEXTURE2 0x00000a00 +#define NV20_3D_RC_IN_ALPHA_C_INPUT_TEXTURE3 0x00000b00 +#define NV20_3D_RC_IN_ALPHA_C_INPUT_SPARE0 0x00000c00 +#define NV20_3D_RC_IN_ALPHA_C_INPUT_SPARE1 0x00000d00 +#define NV20_3D_RC_IN_ALPHA_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 +#define NV20_3D_RC_IN_ALPHA_C_INPUT_E_TIMES_F 0x00000f00 +#define NV20_3D_RC_IN_ALPHA_C_COMPONENT_USAGE__MASK 0x00001000 +#define NV20_3D_RC_IN_ALPHA_C_COMPONENT_USAGE__SHIFT 12 +#define NV20_3D_RC_IN_ALPHA_C_COMPONENT_USAGE_BLUE 0x00000000 +#define NV20_3D_RC_IN_ALPHA_C_COMPONENT_USAGE_ALPHA 0x00001000 +#define NV20_3D_RC_IN_ALPHA_C_MAPPING__MASK 0x0000e000 +#define NV20_3D_RC_IN_ALPHA_C_MAPPING__SHIFT 13 +#define NV20_3D_RC_IN_ALPHA_C_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV20_3D_RC_IN_ALPHA_C_MAPPING_UNSIGNED_INVERT 0x00002000 +#define NV20_3D_RC_IN_ALPHA_C_MAPPING_EXPAND_NORMAL 0x00004000 +#define NV20_3D_RC_IN_ALPHA_C_MAPPING_EXPAND_NEGATE 0x00006000 +#define NV20_3D_RC_IN_ALPHA_C_MAPPING_HALF_BIAS_NORMAL 0x00008000 +#define NV20_3D_RC_IN_ALPHA_C_MAPPING_HALF_BIAS_NEGATE 0x0000a000 +#define NV20_3D_RC_IN_ALPHA_C_MAPPING_SIGNED_IDENTITY 0x0000c000 +#define NV20_3D_RC_IN_ALPHA_C_MAPPING_SIGNED_NEGATE 0x0000e000 +#define NV20_3D_RC_IN_ALPHA_B_INPUT__MASK 0x000f0000 +#define NV20_3D_RC_IN_ALPHA_B_INPUT__SHIFT 16 +#define NV20_3D_RC_IN_ALPHA_B_INPUT_ZERO 0x00000000 +#define NV20_3D_RC_IN_ALPHA_B_INPUT_CONSTANT_COLOR0 0x00010000 +#define NV20_3D_RC_IN_ALPHA_B_INPUT_CONSTANT_COLOR1 0x00020000 +#define NV20_3D_RC_IN_ALPHA_B_INPUT_FOG 0x00030000 +#define NV20_3D_RC_IN_ALPHA_B_INPUT_PRIMARY_COLOR 0x00040000 +#define NV20_3D_RC_IN_ALPHA_B_INPUT_SECONDARY_COLOR 0x00050000 +#define NV20_3D_RC_IN_ALPHA_B_INPUT_TEXTURE0 0x00080000 +#define NV20_3D_RC_IN_ALPHA_B_INPUT_TEXTURE1 0x00090000 +#define NV20_3D_RC_IN_ALPHA_B_INPUT_TEXTURE2 0x000a0000 +#define NV20_3D_RC_IN_ALPHA_B_INPUT_TEXTURE3 0x000b0000 +#define NV20_3D_RC_IN_ALPHA_B_INPUT_SPARE0 0x000c0000 +#define NV20_3D_RC_IN_ALPHA_B_INPUT_SPARE1 0x000d0000 +#define NV20_3D_RC_IN_ALPHA_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 +#define NV20_3D_RC_IN_ALPHA_B_INPUT_E_TIMES_F 0x000f0000 +#define NV20_3D_RC_IN_ALPHA_B_COMPONENT_USAGE__MASK 0x00100000 +#define NV20_3D_RC_IN_ALPHA_B_COMPONENT_USAGE__SHIFT 20 +#define NV20_3D_RC_IN_ALPHA_B_COMPONENT_USAGE_BLUE 0x00000000 +#define NV20_3D_RC_IN_ALPHA_B_COMPONENT_USAGE_ALPHA 0x00100000 +#define NV20_3D_RC_IN_ALPHA_B_MAPPING__MASK 0x00e00000 +#define NV20_3D_RC_IN_ALPHA_B_MAPPING__SHIFT 21 +#define NV20_3D_RC_IN_ALPHA_B_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV20_3D_RC_IN_ALPHA_B_MAPPING_UNSIGNED_INVERT 0x00200000 +#define NV20_3D_RC_IN_ALPHA_B_MAPPING_EXPAND_NORMAL 0x00400000 +#define NV20_3D_RC_IN_ALPHA_B_MAPPING_EXPAND_NEGATE 0x00600000 +#define NV20_3D_RC_IN_ALPHA_B_MAPPING_HALF_BIAS_NORMAL 0x00800000 +#define NV20_3D_RC_IN_ALPHA_B_MAPPING_HALF_BIAS_NEGATE 0x00a00000 +#define NV20_3D_RC_IN_ALPHA_B_MAPPING_SIGNED_IDENTITY 0x00c00000 +#define NV20_3D_RC_IN_ALPHA_B_MAPPING_SIGNED_NEGATE 0x00e00000 +#define NV20_3D_RC_IN_ALPHA_A_INPUT__MASK 0x0f000000 +#define NV20_3D_RC_IN_ALPHA_A_INPUT__SHIFT 24 +#define NV20_3D_RC_IN_ALPHA_A_INPUT_ZERO 0x00000000 +#define NV20_3D_RC_IN_ALPHA_A_INPUT_CONSTANT_COLOR0 0x01000000 +#define NV20_3D_RC_IN_ALPHA_A_INPUT_CONSTANT_COLOR1 0x02000000 +#define NV20_3D_RC_IN_ALPHA_A_INPUT_FOG 0x03000000 +#define NV20_3D_RC_IN_ALPHA_A_INPUT_PRIMARY_COLOR 0x04000000 +#define NV20_3D_RC_IN_ALPHA_A_INPUT_SECONDARY_COLOR 0x05000000 +#define NV20_3D_RC_IN_ALPHA_A_INPUT_TEXTURE0 0x08000000 +#define NV20_3D_RC_IN_ALPHA_A_INPUT_TEXTURE1 0x09000000 +#define NV20_3D_RC_IN_ALPHA_A_INPUT_TEXTURE2 0x0a000000 +#define NV20_3D_RC_IN_ALPHA_A_INPUT_TEXTURE3 0x0b000000 +#define NV20_3D_RC_IN_ALPHA_A_INPUT_SPARE0 0x0c000000 +#define NV20_3D_RC_IN_ALPHA_A_INPUT_SPARE1 0x0d000000 +#define NV20_3D_RC_IN_ALPHA_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 +#define NV20_3D_RC_IN_ALPHA_A_INPUT_E_TIMES_F 0x0f000000 +#define NV20_3D_RC_IN_ALPHA_A_COMPONENT_USAGE__MASK 0x10000000 +#define NV20_3D_RC_IN_ALPHA_A_COMPONENT_USAGE__SHIFT 28 +#define NV20_3D_RC_IN_ALPHA_A_COMPONENT_USAGE_BLUE 0x00000000 +#define NV20_3D_RC_IN_ALPHA_A_COMPONENT_USAGE_ALPHA 0x10000000 +#define NV20_3D_RC_IN_ALPHA_A_MAPPING__MASK 0xe0000000 +#define NV20_3D_RC_IN_ALPHA_A_MAPPING__SHIFT 29 +#define NV20_3D_RC_IN_ALPHA_A_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV20_3D_RC_IN_ALPHA_A_MAPPING_UNSIGNED_INVERT 0x20000000 +#define NV20_3D_RC_IN_ALPHA_A_MAPPING_EXPAND_NORMAL 0x40000000 +#define NV20_3D_RC_IN_ALPHA_A_MAPPING_EXPAND_NEGATE 0x60000000 +#define NV20_3D_RC_IN_ALPHA_A_MAPPING_HALF_BIAS_NORMAL 0x80000000 +#define NV20_3D_RC_IN_ALPHA_A_MAPPING_HALF_BIAS_NEGATE 0xa0000000 +#define NV20_3D_RC_IN_ALPHA_A_MAPPING_SIGNED_IDENTITY 0xc0000000 +#define NV20_3D_RC_IN_ALPHA_A_MAPPING_SIGNED_NEGATE 0xe0000000 + +#define NV20_3D_RC_IN_RGB(i0) (0x00000ac0 + 0x4*(i0)) +#define NV20_3D_RC_IN_RGB_D_INPUT__MASK 0x0000000f +#define NV20_3D_RC_IN_RGB_D_INPUT__SHIFT 0 +#define NV20_3D_RC_IN_RGB_D_INPUT_ZERO 0x00000000 +#define NV20_3D_RC_IN_RGB_D_INPUT_CONSTANT_COLOR0 0x00000001 +#define NV20_3D_RC_IN_RGB_D_INPUT_CONSTANT_COLOR1 0x00000002 +#define NV20_3D_RC_IN_RGB_D_INPUT_FOG 0x00000003 +#define NV20_3D_RC_IN_RGB_D_INPUT_PRIMARY_COLOR 0x00000004 +#define NV20_3D_RC_IN_RGB_D_INPUT_SECONDARY_COLOR 0x00000005 +#define NV20_3D_RC_IN_RGB_D_INPUT_TEXTURE0 0x00000008 +#define NV20_3D_RC_IN_RGB_D_INPUT_TEXTURE1 0x00000009 +#define NV20_3D_RC_IN_RGB_D_INPUT_TEXTURE2 0x0000000a +#define NV20_3D_RC_IN_RGB_D_INPUT_TEXTURE3 0x0000000b +#define NV20_3D_RC_IN_RGB_D_INPUT_SPARE0 0x0000000c +#define NV20_3D_RC_IN_RGB_D_INPUT_SPARE1 0x0000000d +#define NV20_3D_RC_IN_RGB_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e +#define NV20_3D_RC_IN_RGB_D_INPUT_E_TIMES_F 0x0000000f +#define NV20_3D_RC_IN_RGB_D_COMPONENT_USAGE__MASK 0x00000010 +#define NV20_3D_RC_IN_RGB_D_COMPONENT_USAGE__SHIFT 4 +#define NV20_3D_RC_IN_RGB_D_COMPONENT_USAGE_RGB 0x00000000 +#define NV20_3D_RC_IN_RGB_D_COMPONENT_USAGE_ALPHA 0x00000010 +#define NV20_3D_RC_IN_RGB_D_MAPPING__MASK 0x000000e0 +#define NV20_3D_RC_IN_RGB_D_MAPPING__SHIFT 5 +#define NV20_3D_RC_IN_RGB_D_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV20_3D_RC_IN_RGB_D_MAPPING_UNSIGNED_INVERT 0x00000020 +#define NV20_3D_RC_IN_RGB_D_MAPPING_EXPAND_NORMAL 0x00000040 +#define NV20_3D_RC_IN_RGB_D_MAPPING_EXPAND_NEGATE 0x00000060 +#define NV20_3D_RC_IN_RGB_D_MAPPING_HALF_BIAS_NORMAL 0x00000080 +#define NV20_3D_RC_IN_RGB_D_MAPPING_HALF_BIAS_NEGATE 0x000000a0 +#define NV20_3D_RC_IN_RGB_D_MAPPING_SIGNED_IDENTITY 0x000000c0 +#define NV20_3D_RC_IN_RGB_D_MAPPING_SIGNED_NEGATE 0x000000e0 +#define NV20_3D_RC_IN_RGB_C_INPUT__MASK 0x00000f00 +#define NV20_3D_RC_IN_RGB_C_INPUT__SHIFT 8 +#define NV20_3D_RC_IN_RGB_C_INPUT_ZERO 0x00000000 +#define NV20_3D_RC_IN_RGB_C_INPUT_CONSTANT_COLOR0 0x00000100 +#define NV20_3D_RC_IN_RGB_C_INPUT_CONSTANT_COLOR1 0x00000200 +#define NV20_3D_RC_IN_RGB_C_INPUT_FOG 0x00000300 +#define NV20_3D_RC_IN_RGB_C_INPUT_PRIMARY_COLOR 0x00000400 +#define NV20_3D_RC_IN_RGB_C_INPUT_SECONDARY_COLOR 0x00000500 +#define NV20_3D_RC_IN_RGB_C_INPUT_TEXTURE0 0x00000800 +#define NV20_3D_RC_IN_RGB_C_INPUT_TEXTURE1 0x00000900 +#define NV20_3D_RC_IN_RGB_C_INPUT_TEXTURE2 0x00000a00 +#define NV20_3D_RC_IN_RGB_C_INPUT_TEXTURE3 0x00000b00 +#define NV20_3D_RC_IN_RGB_C_INPUT_SPARE0 0x00000c00 +#define NV20_3D_RC_IN_RGB_C_INPUT_SPARE1 0x00000d00 +#define NV20_3D_RC_IN_RGB_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 +#define NV20_3D_RC_IN_RGB_C_INPUT_E_TIMES_F 0x00000f00 +#define NV20_3D_RC_IN_RGB_C_COMPONENT_USAGE__MASK 0x00001000 +#define NV20_3D_RC_IN_RGB_C_COMPONENT_USAGE__SHIFT 12 +#define NV20_3D_RC_IN_RGB_C_COMPONENT_USAGE_RGB 0x00000000 +#define NV20_3D_RC_IN_RGB_C_COMPONENT_USAGE_ALPHA 0x00001000 +#define NV20_3D_RC_IN_RGB_C_MAPPING__MASK 0x0000e000 +#define NV20_3D_RC_IN_RGB_C_MAPPING__SHIFT 13 +#define NV20_3D_RC_IN_RGB_C_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV20_3D_RC_IN_RGB_C_MAPPING_UNSIGNED_INVERT 0x00002000 +#define NV20_3D_RC_IN_RGB_C_MAPPING_EXPAND_NORMAL 0x00004000 +#define NV20_3D_RC_IN_RGB_C_MAPPING_EXPAND_NEGATE 0x00006000 +#define NV20_3D_RC_IN_RGB_C_MAPPING_HALF_BIAS_NORMAL 0x00008000 +#define NV20_3D_RC_IN_RGB_C_MAPPING_HALF_BIAS_NEGATE 0x0000a000 +#define NV20_3D_RC_IN_RGB_C_MAPPING_SIGNED_IDENTITY 0x0000c000 +#define NV20_3D_RC_IN_RGB_C_MAPPING_SIGNED_NEGATE 0x0000e000 +#define NV20_3D_RC_IN_RGB_B_INPUT__MASK 0x000f0000 +#define NV20_3D_RC_IN_RGB_B_INPUT__SHIFT 16 +#define NV20_3D_RC_IN_RGB_B_INPUT_ZERO 0x00000000 +#define NV20_3D_RC_IN_RGB_B_INPUT_CONSTANT_COLOR0 0x00010000 +#define NV20_3D_RC_IN_RGB_B_INPUT_CONSTANT_COLOR1 0x00020000 +#define NV20_3D_RC_IN_RGB_B_INPUT_FOG 0x00030000 +#define NV20_3D_RC_IN_RGB_B_INPUT_PRIMARY_COLOR 0x00040000 +#define NV20_3D_RC_IN_RGB_B_INPUT_SECONDARY_COLOR 0x00050000 +#define NV20_3D_RC_IN_RGB_B_INPUT_TEXTURE0 0x00080000 +#define NV20_3D_RC_IN_RGB_B_INPUT_TEXTURE1 0x00090000 +#define NV20_3D_RC_IN_RGB_B_INPUT_TEXTURE2 0x000a0000 +#define NV20_3D_RC_IN_RGB_B_INPUT_TEXTURE3 0x000b0000 +#define NV20_3D_RC_IN_RGB_B_INPUT_SPARE0 0x000c0000 +#define NV20_3D_RC_IN_RGB_B_INPUT_SPARE1 0x000d0000 +#define NV20_3D_RC_IN_RGB_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 +#define NV20_3D_RC_IN_RGB_B_INPUT_E_TIMES_F 0x000f0000 +#define NV20_3D_RC_IN_RGB_B_COMPONENT_USAGE__MASK 0x00100000 +#define NV20_3D_RC_IN_RGB_B_COMPONENT_USAGE__SHIFT 20 +#define NV20_3D_RC_IN_RGB_B_COMPONENT_USAGE_RGB 0x00000000 +#define NV20_3D_RC_IN_RGB_B_COMPONENT_USAGE_ALPHA 0x00100000 +#define NV20_3D_RC_IN_RGB_B_MAPPING__MASK 0x00e00000 +#define NV20_3D_RC_IN_RGB_B_MAPPING__SHIFT 21 +#define NV20_3D_RC_IN_RGB_B_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV20_3D_RC_IN_RGB_B_MAPPING_UNSIGNED_INVERT 0x00200000 +#define NV20_3D_RC_IN_RGB_B_MAPPING_EXPAND_NORMAL 0x00400000 +#define NV20_3D_RC_IN_RGB_B_MAPPING_EXPAND_NEGATE 0x00600000 +#define NV20_3D_RC_IN_RGB_B_MAPPING_HALF_BIAS_NORMAL 0x00800000 +#define NV20_3D_RC_IN_RGB_B_MAPPING_HALF_BIAS_NEGATE 0x00a00000 +#define NV20_3D_RC_IN_RGB_B_MAPPING_SIGNED_IDENTITY 0x00c00000 +#define NV20_3D_RC_IN_RGB_B_MAPPING_SIGNED_NEGATE 0x00e00000 +#define NV20_3D_RC_IN_RGB_A_INPUT__MASK 0x0f000000 +#define NV20_3D_RC_IN_RGB_A_INPUT__SHIFT 24 +#define NV20_3D_RC_IN_RGB_A_INPUT_ZERO 0x00000000 +#define NV20_3D_RC_IN_RGB_A_INPUT_CONSTANT_COLOR0 0x01000000 +#define NV20_3D_RC_IN_RGB_A_INPUT_CONSTANT_COLOR1 0x02000000 +#define NV20_3D_RC_IN_RGB_A_INPUT_FOG 0x03000000 +#define NV20_3D_RC_IN_RGB_A_INPUT_PRIMARY_COLOR 0x04000000 +#define NV20_3D_RC_IN_RGB_A_INPUT_SECONDARY_COLOR 0x05000000 +#define NV20_3D_RC_IN_RGB_A_INPUT_TEXTURE0 0x08000000 +#define NV20_3D_RC_IN_RGB_A_INPUT_TEXTURE1 0x09000000 +#define NV20_3D_RC_IN_RGB_A_INPUT_TEXTURE2 0x0a000000 +#define NV20_3D_RC_IN_RGB_A_INPUT_TEXTURE3 0x0b000000 +#define NV20_3D_RC_IN_RGB_A_INPUT_SPARE0 0x0c000000 +#define NV20_3D_RC_IN_RGB_A_INPUT_SPARE1 0x0d000000 +#define NV20_3D_RC_IN_RGB_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 +#define NV20_3D_RC_IN_RGB_A_INPUT_E_TIMES_F 0x0f000000 +#define NV20_3D_RC_IN_RGB_A_COMPONENT_USAGE__MASK 0x10000000 +#define NV20_3D_RC_IN_RGB_A_COMPONENT_USAGE__SHIFT 28 +#define NV20_3D_RC_IN_RGB_A_COMPONENT_USAGE_RGB 0x00000000 +#define NV20_3D_RC_IN_RGB_A_COMPONENT_USAGE_ALPHA 0x10000000 +#define NV20_3D_RC_IN_RGB_A_MAPPING__MASK 0xe0000000 +#define NV20_3D_RC_IN_RGB_A_MAPPING__SHIFT 29 +#define NV20_3D_RC_IN_RGB_A_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV20_3D_RC_IN_RGB_A_MAPPING_UNSIGNED_INVERT 0x20000000 +#define NV20_3D_RC_IN_RGB_A_MAPPING_EXPAND_NORMAL 0x40000000 +#define NV20_3D_RC_IN_RGB_A_MAPPING_EXPAND_NEGATE 0x60000000 +#define NV20_3D_RC_IN_RGB_A_MAPPING_HALF_BIAS_NORMAL 0x80000000 +#define NV20_3D_RC_IN_RGB_A_MAPPING_HALF_BIAS_NEGATE 0xa0000000 +#define NV20_3D_RC_IN_RGB_A_MAPPING_SIGNED_IDENTITY 0xc0000000 +#define NV20_3D_RC_IN_RGB_A_MAPPING_SIGNED_NEGATE 0xe0000000 + +#define NV20_3D_RC_CONSTANT_COLOR0(i0) (0x00000a60 + 0x4*(i0)) +#define NV20_3D_RC_CONSTANT_COLOR0_B__MASK 0x000000ff +#define NV20_3D_RC_CONSTANT_COLOR0_B__SHIFT 0 +#define NV20_3D_RC_CONSTANT_COLOR0_G__MASK 0x0000ff00 +#define NV20_3D_RC_CONSTANT_COLOR0_G__SHIFT 8 +#define NV20_3D_RC_CONSTANT_COLOR0_R__MASK 0x00ff0000 +#define NV20_3D_RC_CONSTANT_COLOR0_R__SHIFT 16 +#define NV20_3D_RC_CONSTANT_COLOR0_A__MASK 0xff000000 +#define NV20_3D_RC_CONSTANT_COLOR0_A__SHIFT 24 + +#define NV20_3D_RC_CONSTANT_COLOR1(i0) (0x00000a80 + 0x4*(i0)) +#define NV20_3D_RC_CONSTANT_COLOR1_B__MASK 0x000000ff +#define NV20_3D_RC_CONSTANT_COLOR1_B__SHIFT 0 +#define NV20_3D_RC_CONSTANT_COLOR1_G__MASK 0x0000ff00 +#define NV20_3D_RC_CONSTANT_COLOR1_G__SHIFT 8 +#define NV20_3D_RC_CONSTANT_COLOR1_R__MASK 0x00ff0000 +#define NV20_3D_RC_CONSTANT_COLOR1_R__SHIFT 16 +#define NV20_3D_RC_CONSTANT_COLOR1_A__MASK 0xff000000 +#define NV20_3D_RC_CONSTANT_COLOR1_A__SHIFT 24 + +#define NV20_3D_RC_OUT_ALPHA(i0) (0x00000aa0 + 0x4*(i0)) +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT__MASK 0x0000000f +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT__SHIFT 0 +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT_ZERO 0x00000000 +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT_CONSTANT_COLOR0 0x00000001 +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT_CONSTANT_COLOR1 0x00000002 +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT_FOG 0x00000003 +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT_PRIMARY_COLOR 0x00000004 +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT_SECONDARY_COLOR 0x00000005 +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE0 0x00000008 +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE1 0x00000009 +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE2 0x0000000a +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE3 0x0000000b +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT_SPARE0 0x0000000c +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT_SPARE1 0x0000000d +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e +#define NV20_3D_RC_OUT_ALPHA_CD_OUTPUT_E_TIMES_F 0x0000000f +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT__MASK 0x000000f0 +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT__SHIFT 4 +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT_ZERO 0x00000000 +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT_CONSTANT_COLOR0 0x00000010 +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT_CONSTANT_COLOR1 0x00000020 +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT_FOG 0x00000030 +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT_PRIMARY_COLOR 0x00000040 +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT_SECONDARY_COLOR 0x00000050 +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE0 0x00000080 +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE1 0x00000090 +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE2 0x000000a0 +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE3 0x000000b0 +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT_SPARE0 0x000000c0 +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT_SPARE1 0x000000d0 +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000000e0 +#define NV20_3D_RC_OUT_ALPHA_AB_OUTPUT_E_TIMES_F 0x000000f0 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT__MASK 0x00000f00 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT__SHIFT 8 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT_ZERO 0x00000000 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT_CONSTANT_COLOR0 0x00000100 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT_CONSTANT_COLOR1 0x00000200 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT_FOG 0x00000300 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT_PRIMARY_COLOR 0x00000400 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT_SECONDARY_COLOR 0x00000500 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE0 0x00000800 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE1 0x00000900 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE2 0x00000a00 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE3 0x00000b00 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT_SPARE0 0x00000c00 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT_SPARE1 0x00000d00 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 +#define NV20_3D_RC_OUT_ALPHA_SUM_OUTPUT_E_TIMES_F 0x00000f00 +#define NV20_3D_RC_OUT_ALPHA_CD_DOT_PRODUCT 0x00001000 +#define NV20_3D_RC_OUT_ALPHA_AB_DOT_PRODUCT 0x00002000 +#define NV20_3D_RC_OUT_ALPHA_MUX_SUM 0x00004000 +#define NV20_3D_RC_OUT_ALPHA_BIAS__MASK 0x00008000 +#define NV20_3D_RC_OUT_ALPHA_BIAS__SHIFT 15 +#define NV20_3D_RC_OUT_ALPHA_BIAS_NONE 0x00000000 +#define NV20_3D_RC_OUT_ALPHA_BIAS_BIAS_BY_NEGATIVE_ONE_HALF 0x00008000 +#define NV20_3D_RC_OUT_ALPHA_SCALE__MASK 0x00030000 +#define NV20_3D_RC_OUT_ALPHA_SCALE__SHIFT 16 +#define NV20_3D_RC_OUT_ALPHA_SCALE_NONE 0x00000000 +#define NV20_3D_RC_OUT_ALPHA_SCALE_SCALE_BY_TWO 0x00010000 +#define NV20_3D_RC_OUT_ALPHA_SCALE_SCALE_BY_FOUR 0x00020000 +#define NV20_3D_RC_OUT_ALPHA_SCALE_SCALE_BY_ONE_HALF 0x00030000 + +#define NV20_3D_RC_OUT_RGB(i0) (0x00001e40 + 0x4*(i0)) +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT__MASK 0x0000000f +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT__SHIFT 0 +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT_ZERO 0x00000000 +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT_CONSTANT_COLOR0 0x00000001 +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT_CONSTANT_COLOR1 0x00000002 +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT_FOG 0x00000003 +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT_PRIMARY_COLOR 0x00000004 +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT_SECONDARY_COLOR 0x00000005 +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT_TEXTURE0 0x00000008 +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT_TEXTURE1 0x00000009 +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT_TEXTURE2 0x0000000a +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT_TEXTURE3 0x0000000b +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT_SPARE0 0x0000000c +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT_SPARE1 0x0000000d +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e +#define NV20_3D_RC_OUT_RGB_CD_OUTPUT_E_TIMES_F 0x0000000f +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT__MASK 0x000000f0 +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT__SHIFT 4 +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT_ZERO 0x00000000 +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT_CONSTANT_COLOR0 0x00000010 +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT_CONSTANT_COLOR1 0x00000020 +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT_FOG 0x00000030 +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT_PRIMARY_COLOR 0x00000040 +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT_SECONDARY_COLOR 0x00000050 +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT_TEXTURE0 0x00000080 +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT_TEXTURE1 0x00000090 +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT_TEXTURE2 0x000000a0 +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT_TEXTURE3 0x000000b0 +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT_SPARE0 0x000000c0 +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT_SPARE1 0x000000d0 +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000000e0 +#define NV20_3D_RC_OUT_RGB_AB_OUTPUT_E_TIMES_F 0x000000f0 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT__MASK 0x00000f00 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT__SHIFT 8 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT_ZERO 0x00000000 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT_CONSTANT_COLOR0 0x00000100 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT_CONSTANT_COLOR1 0x00000200 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT_FOG 0x00000300 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT_PRIMARY_COLOR 0x00000400 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT_SECONDARY_COLOR 0x00000500 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT_TEXTURE0 0x00000800 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT_TEXTURE1 0x00000900 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT_TEXTURE2 0x00000a00 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT_TEXTURE3 0x00000b00 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT_SPARE0 0x00000c00 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT_SPARE1 0x00000d00 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 +#define NV20_3D_RC_OUT_RGB_SUM_OUTPUT_E_TIMES_F 0x00000f00 +#define NV20_3D_RC_OUT_RGB_CD_DOT_PRODUCT 0x00001000 +#define NV20_3D_RC_OUT_RGB_AB_DOT_PRODUCT 0x00002000 +#define NV20_3D_RC_OUT_RGB_MUX_SUM 0x00004000 +#define NV20_3D_RC_OUT_RGB_BIAS__MASK 0x00008000 +#define NV20_3D_RC_OUT_RGB_BIAS__SHIFT 15 +#define NV20_3D_RC_OUT_RGB_BIAS_NONE 0x00000000 +#define NV20_3D_RC_OUT_RGB_BIAS_BIAS_BY_NEGATIVE_ONE_HALF 0x00008000 +#define NV20_3D_RC_OUT_RGB_SCALE__MASK 0x00030000 +#define NV20_3D_RC_OUT_RGB_SCALE__SHIFT 16 +#define NV20_3D_RC_OUT_RGB_SCALE_NONE 0x00000000 +#define NV20_3D_RC_OUT_RGB_SCALE_SCALE_BY_TWO 0x00010000 +#define NV20_3D_RC_OUT_RGB_SCALE_SCALE_BY_FOUR 0x00020000 +#define NV20_3D_RC_OUT_RGB_SCALE_SCALE_BY_ONE_HALF 0x00030000 + +#define NV20_3D_RC_FINAL0 0x00000288 +#define NV20_3D_RC_FINAL0_D_INPUT__MASK 0x0000000f +#define NV20_3D_RC_FINAL0_D_INPUT__SHIFT 0 +#define NV20_3D_RC_FINAL0_D_INPUT_ZERO 0x00000000 +#define NV20_3D_RC_FINAL0_D_INPUT_CONSTANT_COLOR0 0x00000001 +#define NV20_3D_RC_FINAL0_D_INPUT_CONSTANT_COLOR1 0x00000002 +#define NV20_3D_RC_FINAL0_D_INPUT_FOG 0x00000003 +#define NV20_3D_RC_FINAL0_D_INPUT_PRIMARY_COLOR 0x00000004 +#define NV20_3D_RC_FINAL0_D_INPUT_SECONDARY_COLOR 0x00000005 +#define NV20_3D_RC_FINAL0_D_INPUT_TEXTURE0 0x00000008 +#define NV20_3D_RC_FINAL0_D_INPUT_TEXTURE1 0x00000009 +#define NV20_3D_RC_FINAL0_D_INPUT_TEXTURE2 0x0000000a +#define NV20_3D_RC_FINAL0_D_INPUT_TEXTURE3 0x0000000b +#define NV20_3D_RC_FINAL0_D_INPUT_SPARE0 0x0000000c +#define NV20_3D_RC_FINAL0_D_INPUT_SPARE1 0x0000000d +#define NV20_3D_RC_FINAL0_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0000000e +#define NV20_3D_RC_FINAL0_D_INPUT_E_TIMES_F 0x0000000f +#define NV20_3D_RC_FINAL0_D_COMPONENT_USAGE__MASK 0x00000010 +#define NV20_3D_RC_FINAL0_D_COMPONENT_USAGE__SHIFT 4 +#define NV20_3D_RC_FINAL0_D_COMPONENT_USAGE_RGB 0x00000000 +#define NV20_3D_RC_FINAL0_D_COMPONENT_USAGE_ALPHA 0x00000010 +#define NV20_3D_RC_FINAL0_D_MAPPING__MASK 0x000000e0 +#define NV20_3D_RC_FINAL0_D_MAPPING__SHIFT 5 +#define NV20_3D_RC_FINAL0_D_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV20_3D_RC_FINAL0_D_MAPPING_UNSIGNED_INVERT 0x00000020 +#define NV20_3D_RC_FINAL0_D_MAPPING_EXPAND_NORMAL 0x00000040 +#define NV20_3D_RC_FINAL0_D_MAPPING_EXPAND_NEGATE 0x00000060 +#define NV20_3D_RC_FINAL0_D_MAPPING_HALF_BIAS_NORMAL 0x00000080 +#define NV20_3D_RC_FINAL0_D_MAPPING_HALF_BIAS_NEGATE 0x000000a0 +#define NV20_3D_RC_FINAL0_D_MAPPING_SIGNED_IDENTITY 0x000000c0 +#define NV20_3D_RC_FINAL0_D_MAPPING_SIGNED_NEGATE 0x000000e0 +#define NV20_3D_RC_FINAL0_C_INPUT__MASK 0x00000f00 +#define NV20_3D_RC_FINAL0_C_INPUT__SHIFT 8 +#define NV20_3D_RC_FINAL0_C_INPUT_ZERO 0x00000000 +#define NV20_3D_RC_FINAL0_C_INPUT_CONSTANT_COLOR0 0x00000100 +#define NV20_3D_RC_FINAL0_C_INPUT_CONSTANT_COLOR1 0x00000200 +#define NV20_3D_RC_FINAL0_C_INPUT_FOG 0x00000300 +#define NV20_3D_RC_FINAL0_C_INPUT_PRIMARY_COLOR 0x00000400 +#define NV20_3D_RC_FINAL0_C_INPUT_SECONDARY_COLOR 0x00000500 +#define NV20_3D_RC_FINAL0_C_INPUT_TEXTURE0 0x00000800 +#define NV20_3D_RC_FINAL0_C_INPUT_TEXTURE1 0x00000900 +#define NV20_3D_RC_FINAL0_C_INPUT_TEXTURE2 0x00000a00 +#define NV20_3D_RC_FINAL0_C_INPUT_TEXTURE3 0x00000b00 +#define NV20_3D_RC_FINAL0_C_INPUT_SPARE0 0x00000c00 +#define NV20_3D_RC_FINAL0_C_INPUT_SPARE1 0x00000d00 +#define NV20_3D_RC_FINAL0_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 +#define NV20_3D_RC_FINAL0_C_INPUT_E_TIMES_F 0x00000f00 +#define NV20_3D_RC_FINAL0_C_COMPONENT_USAGE__MASK 0x00001000 +#define NV20_3D_RC_FINAL0_C_COMPONENT_USAGE__SHIFT 12 +#define NV20_3D_RC_FINAL0_C_COMPONENT_USAGE_RGB 0x00000000 +#define NV20_3D_RC_FINAL0_C_COMPONENT_USAGE_ALPHA 0x00001000 +#define NV20_3D_RC_FINAL0_C_MAPPING__MASK 0x0000e000 +#define NV20_3D_RC_FINAL0_C_MAPPING__SHIFT 13 +#define NV20_3D_RC_FINAL0_C_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV20_3D_RC_FINAL0_C_MAPPING_UNSIGNED_INVERT 0x00002000 +#define NV20_3D_RC_FINAL0_C_MAPPING_EXPAND_NORMAL 0x00004000 +#define NV20_3D_RC_FINAL0_C_MAPPING_EXPAND_NEGATE 0x00006000 +#define NV20_3D_RC_FINAL0_C_MAPPING_HALF_BIAS_NORMAL 0x00008000 +#define NV20_3D_RC_FINAL0_C_MAPPING_HALF_BIAS_NEGATE 0x0000a000 +#define NV20_3D_RC_FINAL0_C_MAPPING_SIGNED_IDENTITY 0x0000c000 +#define NV20_3D_RC_FINAL0_C_MAPPING_SIGNED_NEGATE 0x0000e000 +#define NV20_3D_RC_FINAL0_B_INPUT__MASK 0x000f0000 +#define NV20_3D_RC_FINAL0_B_INPUT__SHIFT 16 +#define NV20_3D_RC_FINAL0_B_INPUT_ZERO 0x00000000 +#define NV20_3D_RC_FINAL0_B_INPUT_CONSTANT_COLOR0 0x00010000 +#define NV20_3D_RC_FINAL0_B_INPUT_CONSTANT_COLOR1 0x00020000 +#define NV20_3D_RC_FINAL0_B_INPUT_FOG 0x00030000 +#define NV20_3D_RC_FINAL0_B_INPUT_PRIMARY_COLOR 0x00040000 +#define NV20_3D_RC_FINAL0_B_INPUT_SECONDARY_COLOR 0x00050000 +#define NV20_3D_RC_FINAL0_B_INPUT_TEXTURE0 0x00080000 +#define NV20_3D_RC_FINAL0_B_INPUT_TEXTURE1 0x00090000 +#define NV20_3D_RC_FINAL0_B_INPUT_TEXTURE2 0x000a0000 +#define NV20_3D_RC_FINAL0_B_INPUT_TEXTURE3 0x000b0000 +#define NV20_3D_RC_FINAL0_B_INPUT_SPARE0 0x000c0000 +#define NV20_3D_RC_FINAL0_B_INPUT_SPARE1 0x000d0000 +#define NV20_3D_RC_FINAL0_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 +#define NV20_3D_RC_FINAL0_B_INPUT_E_TIMES_F 0x000f0000 +#define NV20_3D_RC_FINAL0_B_COMPONENT_USAGE__MASK 0x00100000 +#define NV20_3D_RC_FINAL0_B_COMPONENT_USAGE__SHIFT 20 +#define NV20_3D_RC_FINAL0_B_COMPONENT_USAGE_RGB 0x00000000 +#define NV20_3D_RC_FINAL0_B_COMPONENT_USAGE_ALPHA 0x00100000 +#define NV20_3D_RC_FINAL0_B_MAPPING__MASK 0x00e00000 +#define NV20_3D_RC_FINAL0_B_MAPPING__SHIFT 21 +#define NV20_3D_RC_FINAL0_B_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV20_3D_RC_FINAL0_B_MAPPING_UNSIGNED_INVERT 0x00200000 +#define NV20_3D_RC_FINAL0_B_MAPPING_EXPAND_NORMAL 0x00400000 +#define NV20_3D_RC_FINAL0_B_MAPPING_EXPAND_NEGATE 0x00600000 +#define NV20_3D_RC_FINAL0_B_MAPPING_HALF_BIAS_NORMAL 0x00800000 +#define NV20_3D_RC_FINAL0_B_MAPPING_HALF_BIAS_NEGATE 0x00a00000 +#define NV20_3D_RC_FINAL0_B_MAPPING_SIGNED_IDENTITY 0x00c00000 +#define NV20_3D_RC_FINAL0_B_MAPPING_SIGNED_NEGATE 0x00e00000 +#define NV20_3D_RC_FINAL0_A_INPUT__MASK 0x0f000000 +#define NV20_3D_RC_FINAL0_A_INPUT__SHIFT 24 +#define NV20_3D_RC_FINAL0_A_INPUT_ZERO 0x00000000 +#define NV20_3D_RC_FINAL0_A_INPUT_CONSTANT_COLOR0 0x01000000 +#define NV20_3D_RC_FINAL0_A_INPUT_CONSTANT_COLOR1 0x02000000 +#define NV20_3D_RC_FINAL0_A_INPUT_FOG 0x03000000 +#define NV20_3D_RC_FINAL0_A_INPUT_PRIMARY_COLOR 0x04000000 +#define NV20_3D_RC_FINAL0_A_INPUT_SECONDARY_COLOR 0x05000000 +#define NV20_3D_RC_FINAL0_A_INPUT_TEXTURE0 0x08000000 +#define NV20_3D_RC_FINAL0_A_INPUT_TEXTURE1 0x09000000 +#define NV20_3D_RC_FINAL0_A_INPUT_TEXTURE2 0x0a000000 +#define NV20_3D_RC_FINAL0_A_INPUT_TEXTURE3 0x0b000000 +#define NV20_3D_RC_FINAL0_A_INPUT_SPARE0 0x0c000000 +#define NV20_3D_RC_FINAL0_A_INPUT_SPARE1 0x0d000000 +#define NV20_3D_RC_FINAL0_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 +#define NV20_3D_RC_FINAL0_A_INPUT_E_TIMES_F 0x0f000000 +#define NV20_3D_RC_FINAL0_A_COMPONENT_USAGE__MASK 0x10000000 +#define NV20_3D_RC_FINAL0_A_COMPONENT_USAGE__SHIFT 28 +#define NV20_3D_RC_FINAL0_A_COMPONENT_USAGE_RGB 0x00000000 +#define NV20_3D_RC_FINAL0_A_COMPONENT_USAGE_ALPHA 0x10000000 +#define NV20_3D_RC_FINAL0_A_MAPPING__MASK 0xe0000000 +#define NV20_3D_RC_FINAL0_A_MAPPING__SHIFT 29 +#define NV20_3D_RC_FINAL0_A_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV20_3D_RC_FINAL0_A_MAPPING_UNSIGNED_INVERT 0x20000000 +#define NV20_3D_RC_FINAL0_A_MAPPING_EXPAND_NORMAL 0x40000000 +#define NV20_3D_RC_FINAL0_A_MAPPING_EXPAND_NEGATE 0x60000000 +#define NV20_3D_RC_FINAL0_A_MAPPING_HALF_BIAS_NORMAL 0x80000000 +#define NV20_3D_RC_FINAL0_A_MAPPING_HALF_BIAS_NEGATE 0xa0000000 +#define NV20_3D_RC_FINAL0_A_MAPPING_SIGNED_IDENTITY 0xc0000000 +#define NV20_3D_RC_FINAL0_A_MAPPING_SIGNED_NEGATE 0xe0000000 + +#define NV20_3D_RC_FINAL1 0x0000028c +#define NV20_3D_RC_FINAL1_COLOR_SUM_CLAMP 0x00000080 +#define NV20_3D_RC_FINAL1_G_INPUT__MASK 0x00000f00 +#define NV20_3D_RC_FINAL1_G_INPUT__SHIFT 8 +#define NV20_3D_RC_FINAL1_G_INPUT_ZERO 0x00000000 +#define NV20_3D_RC_FINAL1_G_INPUT_CONSTANT_COLOR0 0x00000100 +#define NV20_3D_RC_FINAL1_G_INPUT_CONSTANT_COLOR1 0x00000200 +#define NV20_3D_RC_FINAL1_G_INPUT_FOG 0x00000300 +#define NV20_3D_RC_FINAL1_G_INPUT_PRIMARY_COLOR 0x00000400 +#define NV20_3D_RC_FINAL1_G_INPUT_SECONDARY_COLOR 0x00000500 +#define NV20_3D_RC_FINAL1_G_INPUT_TEXTURE0 0x00000800 +#define NV20_3D_RC_FINAL1_G_INPUT_TEXTURE1 0x00000900 +#define NV20_3D_RC_FINAL1_G_INPUT_TEXTURE2 0x00000a00 +#define NV20_3D_RC_FINAL1_G_INPUT_TEXTURE3 0x00000b00 +#define NV20_3D_RC_FINAL1_G_INPUT_SPARE0 0x00000c00 +#define NV20_3D_RC_FINAL1_G_INPUT_SPARE1 0x00000d00 +#define NV20_3D_RC_FINAL1_G_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x00000e00 +#define NV20_3D_RC_FINAL1_G_INPUT_E_TIMES_F 0x00000f00 +#define NV20_3D_RC_FINAL1_G_COMPONENT_USAGE__MASK 0x00001000 +#define NV20_3D_RC_FINAL1_G_COMPONENT_USAGE__SHIFT 12 +#define NV20_3D_RC_FINAL1_G_COMPONENT_USAGE_RGB 0x00000000 +#define NV20_3D_RC_FINAL1_G_COMPONENT_USAGE_ALPHA 0x00001000 +#define NV20_3D_RC_FINAL1_G_MAPPING__MASK 0x0000e000 +#define NV20_3D_RC_FINAL1_G_MAPPING__SHIFT 13 +#define NV20_3D_RC_FINAL1_G_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV20_3D_RC_FINAL1_G_MAPPING_UNSIGNED_INVERT 0x00002000 +#define NV20_3D_RC_FINAL1_G_MAPPING_EXPAND_NORMAL 0x00004000 +#define NV20_3D_RC_FINAL1_G_MAPPING_EXPAND_NEGATE 0x00006000 +#define NV20_3D_RC_FINAL1_G_MAPPING_HALF_BIAS_NORMAL 0x00008000 +#define NV20_3D_RC_FINAL1_G_MAPPING_HALF_BIAS_NEGATE 0x0000a000 +#define NV20_3D_RC_FINAL1_G_MAPPING_SIGNED_IDENTITY 0x0000c000 +#define NV20_3D_RC_FINAL1_G_MAPPING_SIGNED_NEGATE 0x0000e000 +#define NV20_3D_RC_FINAL1_F_INPUT__MASK 0x000f0000 +#define NV20_3D_RC_FINAL1_F_INPUT__SHIFT 16 +#define NV20_3D_RC_FINAL1_F_INPUT_ZERO 0x00000000 +#define NV20_3D_RC_FINAL1_F_INPUT_CONSTANT_COLOR0 0x00010000 +#define NV20_3D_RC_FINAL1_F_INPUT_CONSTANT_COLOR1 0x00020000 +#define NV20_3D_RC_FINAL1_F_INPUT_FOG 0x00030000 +#define NV20_3D_RC_FINAL1_F_INPUT_PRIMARY_COLOR 0x00040000 +#define NV20_3D_RC_FINAL1_F_INPUT_SECONDARY_COLOR 0x00050000 +#define NV20_3D_RC_FINAL1_F_INPUT_TEXTURE0 0x00080000 +#define NV20_3D_RC_FINAL1_F_INPUT_TEXTURE1 0x00090000 +#define NV20_3D_RC_FINAL1_F_INPUT_TEXTURE2 0x000a0000 +#define NV20_3D_RC_FINAL1_F_INPUT_TEXTURE3 0x000b0000 +#define NV20_3D_RC_FINAL1_F_INPUT_SPARE0 0x000c0000 +#define NV20_3D_RC_FINAL1_F_INPUT_SPARE1 0x000d0000 +#define NV20_3D_RC_FINAL1_F_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x000e0000 +#define NV20_3D_RC_FINAL1_F_INPUT_E_TIMES_F 0x000f0000 +#define NV20_3D_RC_FINAL1_F_COMPONENT_USAGE__MASK 0x00100000 +#define NV20_3D_RC_FINAL1_F_COMPONENT_USAGE__SHIFT 20 +#define NV20_3D_RC_FINAL1_F_COMPONENT_USAGE_RGB 0x00000000 +#define NV20_3D_RC_FINAL1_F_COMPONENT_USAGE_ALPHA 0x00100000 +#define NV20_3D_RC_FINAL1_F_MAPPING__MASK 0x00e00000 +#define NV20_3D_RC_FINAL1_F_MAPPING__SHIFT 21 +#define NV20_3D_RC_FINAL1_F_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV20_3D_RC_FINAL1_F_MAPPING_UNSIGNED_INVERT 0x00200000 +#define NV20_3D_RC_FINAL1_F_MAPPING_EXPAND_NORMAL 0x00400000 +#define NV20_3D_RC_FINAL1_F_MAPPING_EXPAND_NEGATE 0x00600000 +#define NV20_3D_RC_FINAL1_F_MAPPING_HALF_BIAS_NORMAL 0x00800000 +#define NV20_3D_RC_FINAL1_F_MAPPING_HALF_BIAS_NEGATE 0x00a00000 +#define NV20_3D_RC_FINAL1_F_MAPPING_SIGNED_IDENTITY 0x00c00000 +#define NV20_3D_RC_FINAL1_F_MAPPING_SIGNED_NEGATE 0x00e00000 +#define NV20_3D_RC_FINAL1_E_INPUT__MASK 0x0f000000 +#define NV20_3D_RC_FINAL1_E_INPUT__SHIFT 24 +#define NV20_3D_RC_FINAL1_E_INPUT_ZERO 0x00000000 +#define NV20_3D_RC_FINAL1_E_INPUT_CONSTANT_COLOR0 0x01000000 +#define NV20_3D_RC_FINAL1_E_INPUT_CONSTANT_COLOR1 0x02000000 +#define NV20_3D_RC_FINAL1_E_INPUT_FOG 0x03000000 +#define NV20_3D_RC_FINAL1_E_INPUT_PRIMARY_COLOR 0x04000000 +#define NV20_3D_RC_FINAL1_E_INPUT_SECONDARY_COLOR 0x05000000 +#define NV20_3D_RC_FINAL1_E_INPUT_TEXTURE0 0x08000000 +#define NV20_3D_RC_FINAL1_E_INPUT_TEXTURE1 0x09000000 +#define NV20_3D_RC_FINAL1_E_INPUT_TEXTURE2 0x0a000000 +#define NV20_3D_RC_FINAL1_E_INPUT_TEXTURE3 0x0b000000 +#define NV20_3D_RC_FINAL1_E_INPUT_SPARE0 0x0c000000 +#define NV20_3D_RC_FINAL1_E_INPUT_SPARE1 0x0d000000 +#define NV20_3D_RC_FINAL1_E_INPUT_SPARE0_PLUS_SECONDARY_COLOR 0x0e000000 +#define NV20_3D_RC_FINAL1_E_INPUT_E_TIMES_F 0x0f000000 +#define NV20_3D_RC_FINAL1_E_COMPONENT_USAGE__MASK 0x10000000 +#define NV20_3D_RC_FINAL1_E_COMPONENT_USAGE__SHIFT 28 +#define NV20_3D_RC_FINAL1_E_COMPONENT_USAGE_RGB 0x00000000 +#define NV20_3D_RC_FINAL1_E_COMPONENT_USAGE_ALPHA 0x10000000 +#define NV20_3D_RC_FINAL1_E_MAPPING__MASK 0xe0000000 +#define NV20_3D_RC_FINAL1_E_MAPPING__SHIFT 29 +#define NV20_3D_RC_FINAL1_E_MAPPING_UNSIGNED_IDENTITY 0x00000000 +#define NV20_3D_RC_FINAL1_E_MAPPING_UNSIGNED_INVERT 0x20000000 +#define NV20_3D_RC_FINAL1_E_MAPPING_EXPAND_NORMAL 0x40000000 +#define NV20_3D_RC_FINAL1_E_MAPPING_EXPAND_NEGATE 0x60000000 +#define NV20_3D_RC_FINAL1_E_MAPPING_HALF_BIAS_NORMAL 0x80000000 +#define NV20_3D_RC_FINAL1_E_MAPPING_HALF_BIAS_NEGATE 0xa0000000 +#define NV20_3D_RC_FINAL1_E_MAPPING_SIGNED_IDENTITY 0xc0000000 +#define NV20_3D_RC_FINAL1_E_MAPPING_SIGNED_NEGATE 0xe0000000 + +#define NV20_3D_RC_COLOR0 0x00001e20 +#define NV20_3D_RC_COLOR0_B__MASK 0x000000ff +#define NV20_3D_RC_COLOR0_B__SHIFT 0 +#define NV20_3D_RC_COLOR0_G__MASK 0x0000ff00 +#define NV20_3D_RC_COLOR0_G__SHIFT 8 +#define NV20_3D_RC_COLOR0_R__MASK 0x00ff0000 +#define NV20_3D_RC_COLOR0_R__SHIFT 16 +#define NV20_3D_RC_COLOR0_A__MASK 0xff000000 +#define NV20_3D_RC_COLOR0_A__SHIFT 24 + +#define NV20_3D_RC_COLOR1 0x00001e24 +#define NV20_3D_RC_COLOR1_B__MASK 0x000000ff +#define NV20_3D_RC_COLOR1_B__SHIFT 0 +#define NV20_3D_RC_COLOR1_G__MASK 0x0000ff00 +#define NV20_3D_RC_COLOR1_G__SHIFT 8 +#define NV20_3D_RC_COLOR1_R__MASK 0x00ff0000 +#define NV20_3D_RC_COLOR1_R__SHIFT 16 +#define NV20_3D_RC_COLOR1_A__MASK 0xff000000 +#define NV20_3D_RC_COLOR1_A__SHIFT 24 + +#define NV20_3D_RC_ENABLE 0x00001e60 +#define NV20_3D_RC_ENABLE_NUM_COMBINERS__MASK 0x0000000f +#define NV20_3D_RC_ENABLE_NUM_COMBINERS__SHIFT 0 + + +#define NV20_3D_POINT_SIZE 0x0000043c + +#define NV20_3D_POINT_PARAMETER(i0) (0x00000a30 + 0x4*(i0)) +#define NV20_3D_POINT_PARAMETER__ESIZE 0x00000004 +#define NV20_3D_POINT_PARAMETER__LEN 0x00000008 + +#define NV20_3D_POLYGON_STIPPLE_ENABLE 0x0000147c + +#define NV20_3D_POLYGON_STIPPLE_PATTERN(i0) (0x00001480 + 0x4*(i0)) +#define NV20_3D_POLYGON_STIPPLE_PATTERN__ESIZE 0x00000004 +#define NV20_3D_POLYGON_STIPPLE_PATTERN__LEN 0x00000020 + +#define NV20_3D_COLOR_LOGIC_OP_ENABLE 0x000017bc + +#define NV20_3D_COLOR_LOGIC_OP_OP 0x000017c0 +#define NV20_3D_COLOR_LOGIC_OP_OP_CLEAR 0x00001500 +#define NV20_3D_COLOR_LOGIC_OP_OP_AND 0x00001501 +#define NV20_3D_COLOR_LOGIC_OP_OP_AND_REVERSE 0x00001502 +#define NV20_3D_COLOR_LOGIC_OP_OP_COPY 0x00001503 +#define NV20_3D_COLOR_LOGIC_OP_OP_AND_INVERTED 0x00001504 +#define NV20_3D_COLOR_LOGIC_OP_OP_NOOP 0x00001505 +#define NV20_3D_COLOR_LOGIC_OP_OP_XOR 0x00001506 +#define NV20_3D_COLOR_LOGIC_OP_OP_OR 0x00001507 +#define NV20_3D_COLOR_LOGIC_OP_OP_NOR 0x00001508 +#define NV20_3D_COLOR_LOGIC_OP_OP_EQUIV 0x00001509 +#define NV20_3D_COLOR_LOGIC_OP_OP_INVERT 0x0000150a +#define NV20_3D_COLOR_LOGIC_OP_OP_OR_REVERSE 0x0000150b +#define NV20_3D_COLOR_LOGIC_OP_OP_COPY_INVERTED 0x0000150c +#define NV20_3D_COLOR_LOGIC_OP_OP_OR_INVERTED 0x0000150d +#define NV20_3D_COLOR_LOGIC_OP_OP_NAND 0x0000150e +#define NV20_3D_COLOR_LOGIC_OP_OP_SET 0x0000150f + +#define NV20_3D_DEPTH_CLAMP 0x00001d78 + +#define NV20_3D_MULTISAMPLE_CONTROL 0x00001d7c + + +#define NV20_3D_CLEAR_DEPTH_VALUE 0x00001d8c + +#define NV20_3D_CLEAR_VALUE 0x00001d90 + +#define NV20_3D_CLEAR_BUFFERS 0x00001d94 +#define NV20_3D_CLEAR_BUFFERS_COLOR_A 0x00000080 +#define NV20_3D_CLEAR_BUFFERS_COLOR_B 0x00000040 +#define NV20_3D_CLEAR_BUFFERS_COLOR_G 0x00000020 +#define NV20_3D_CLEAR_BUFFERS_COLOR_R 0x00000010 +#define NV20_3D_CLEAR_BUFFERS_STENCIL 0x00000002 +#define NV20_3D_CLEAR_BUFFERS_DEPTH 0x00000001 + + +#define NV25_3D_DMA_HIERZ 0x000001b0 + +#define NV25_3D_HIERZ_PITCH 0x0000022c + +#define NV25_3D_HIERZ_OFFSET 0x00000230 + +#define NV20_3D_UNK09F8 0x000009f8 + +#define NV20_3D_UNK09FC 0x000009fc + +#define NV20_3D_UNK17CC 0x000017cc + +#define NV20_3D_UNK17E0 0x000017e0 + +#define NV20_3D_UNK17E4 0x000017e4 + +#define NV20_3D_UNK17E8 0x000017e8 + +#define NV20_3D_UNK17EC 0x000017ec + +#define NV20_3D_UNK17F0 0x000017f0 + +#define NV20_3D_UNK17F4 0x000017f4 + +#define NV20_3D_UNK1D80 0x00001d80 + +#define NV20_3D_UNK1D84 0x00001d84 + +#define NV20_3D_UNK1E68 0x00001e68 + +#define NV20_3D_UNK1E98 0x00001e98 + + +#define NV25_3D_UNK01AC 0x000001ac + +#define NV25_3D_UNK0A1C 0x00000a1c + +#define NV25_3D_UNK1D88 0x00001d88 + +#define NV25_3D_UNK1DA4 0x00001da4 + + +#endif /* NV20_3D_XML */ diff --git a/src/mesa/drivers/dri/nouveau/nv20_context.c b/src/mesa/drivers/dri/nouveau/nv20_context.c index c6111a2a9a..e0483b261e 100644 --- a/src/mesa/drivers/dri/nouveau/nv20_context.c +++ b/src/mesa/drivers/dri/nouveau/nv20_context.c @@ -26,7 +26,10 @@ #include "nouveau_driver.h" #include "nouveau_context.h" -#include "nouveau_class.h" +#include "nouveau_fbo.h" +#include "nouveau_util.h" +#include "nv_object.xml.h" +#include "nv20_3d.xml.h" #include "nv04_driver.h" #include "nv10_driver.h" #include "nv20_driver.h" @@ -40,6 +43,57 @@ static const struct dri_extension nv20_extensions[] = { }; static void +nv20_clear(struct gl_context *ctx, GLbitfield buffers) +{ + struct nouveau_channel *chan = context_chan(ctx); + struct nouveau_grobj *kelvin = context_eng3d(ctx); + struct gl_framebuffer *fb = ctx->DrawBuffer; + uint32_t clear = 0; + + nouveau_validate_framebuffer(ctx); + + if (buffers & BUFFER_BITS_COLOR) { + struct nouveau_surface *s = &to_nouveau_renderbuffer( + fb->_ColorDrawBuffers[0])->surface; + + if (ctx->Color.ColorMask[0][RCOMP]) + clear |= NV20_3D_CLEAR_BUFFERS_COLOR_R; + if (ctx->Color.ColorMask[0][GCOMP]) + clear |= NV20_3D_CLEAR_BUFFERS_COLOR_G; + if (ctx->Color.ColorMask[0][BCOMP]) + clear |= NV20_3D_CLEAR_BUFFERS_COLOR_B; + if (ctx->Color.ColorMask[0][ACOMP]) + clear |= NV20_3D_CLEAR_BUFFERS_COLOR_A; + + BEGIN_RING(chan, kelvin, NV20_3D_CLEAR_VALUE, 1); + OUT_RING(chan, pack_rgba_f(s->format, ctx->Color.ClearColor)); + + buffers &= ~BUFFER_BITS_COLOR; + } + + if (buffers & (BUFFER_BIT_DEPTH | BUFFER_BIT_STENCIL)) { + struct nouveau_surface *s = &to_nouveau_renderbuffer( + fb->_DepthBuffer->Wrapped)->surface; + + if (buffers & BUFFER_BIT_DEPTH && ctx->Depth.Mask) + clear |= NV20_3D_CLEAR_BUFFERS_DEPTH; + if (buffers & BUFFER_BIT_STENCIL && ctx->Stencil.WriteMask[0]) + clear |= NV20_3D_CLEAR_BUFFERS_STENCIL; + + BEGIN_RING(chan, kelvin, NV20_3D_CLEAR_DEPTH_VALUE, 1); + OUT_RING(chan, pack_zs_f(s->format, ctx->Depth.Clear, + ctx->Stencil.Clear)); + + buffers &= ~(BUFFER_BIT_DEPTH | BUFFER_BIT_STENCIL); + } + + BEGIN_RING(chan, kelvin, NV20_3D_CLEAR_BUFFERS, 1); + OUT_RING(chan, clear); + + nouveau_clear(ctx, buffers); +} + +static void nv20_hwctx_init(struct gl_context *ctx) { struct nouveau_channel *chan = context_chan(ctx); @@ -47,38 +101,38 @@ nv20_hwctx_init(struct gl_context *ctx) struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw; int i; - BEGIN_RING(chan, kelvin, NV20TCL_DMA_NOTIFY, 1); + BEGIN_RING(chan, kelvin, NV20_3D_DMA_NOTIFY, 1); OUT_RING (chan, hw->ntfy->handle); - BEGIN_RING(chan, kelvin, NV20TCL_DMA_TEXTURE0, 2); + BEGIN_RING(chan, kelvin, NV20_3D_DMA_TEXTURE0, 2); OUT_RING (chan, chan->vram->handle); OUT_RING (chan, chan->gart->handle); - BEGIN_RING(chan, kelvin, NV20TCL_DMA_COLOR, 2); + BEGIN_RING(chan, kelvin, NV20_3D_DMA_COLOR, 2); OUT_RING (chan, chan->vram->handle); OUT_RING (chan, chan->vram->handle); - BEGIN_RING(chan, kelvin, NV20TCL_DMA_VTXBUF0, 2); + BEGIN_RING(chan, kelvin, NV20_3D_DMA_VTXBUF0, 2); OUT_RING(chan, chan->vram->handle); OUT_RING(chan, chan->gart->handle); - BEGIN_RING(chan, kelvin, NV20TCL_DMA_QUERY, 1); + BEGIN_RING(chan, kelvin, NV20_3D_DMA_QUERY, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_RT_HORIZ, 2); + BEGIN_RING(chan, kelvin, NV20_3D_RT_HORIZ, 2); OUT_RING (chan, 0); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_VIEWPORT_CLIP_HORIZ(0), 1); + BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_CLIP_HORIZ(0), 1); OUT_RING (chan, 0xfff << 16 | 0x0); - BEGIN_RING(chan, kelvin, NV20TCL_VIEWPORT_CLIP_VERT(0), 1); + BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_CLIP_VERT(0), 1); OUT_RING (chan, 0xfff << 16 | 0x0); - for (i = 1; i < NV20TCL_VIEWPORT_CLIP_HORIZ__SIZE; i++) { - BEGIN_RING(chan, kelvin, NV20TCL_VIEWPORT_CLIP_HORIZ(i), 1); + for (i = 1; i < NV20_3D_VIEWPORT_CLIP_HORIZ__LEN; i++) { + BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_CLIP_HORIZ(i), 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_VIEWPORT_CLIP_VERT(i), 1); + BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_CLIP_VERT(i), 1); OUT_RING (chan, 0); } - BEGIN_RING(chan, kelvin, NV20TCL_VIEWPORT_CLIP_MODE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_CLIP_MODE, 1); OUT_RING (chan, 0); BEGIN_RING(chan, kelvin, 0x17e0, 3); @@ -87,13 +141,13 @@ nv20_hwctx_init(struct gl_context *ctx) OUT_RINGf (chan, 1.0); if (context_chipset(ctx) >= 0x25) { - BEGIN_RING(chan, kelvin, NV20TCL_TX_RCOMP, 1); - OUT_RING (chan, NV20TCL_TX_RCOMP_LEQUAL | 0xdb0); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_RCOMP, 1); + OUT_RING (chan, NV20_3D_TEX_RCOMP_LEQUAL | 0xdb0); } else { BEGIN_RING(chan, kelvin, 0x1e68, 1); OUT_RING (chan, 0x4b800000); /* 16777216.000000 */ - BEGIN_RING(chan, kelvin, NV20TCL_TX_RCOMP, 1); - OUT_RING (chan, NV20TCL_TX_RCOMP_LEQUAL); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_RCOMP, 1); + OUT_RING (chan, NV20_3D_TEX_RCOMP_LEQUAL); } BEGIN_RING(chan, kelvin, 0x290, 1); @@ -113,19 +167,19 @@ nv20_hwctx_init(struct gl_context *ctx) BEGIN_RING(chan, kelvin, 0x1d88, 1); OUT_RING (chan, 3); - BEGIN_RING(chan, kelvin, NV25TCL_DMA_IN_MEMORY9, 1); + BEGIN_RING(chan, kelvin, NV25_3D_DMA_HIERZ, 1); OUT_RING (chan, chan->vram->handle); - BEGIN_RING(chan, kelvin, NV25TCL_DMA_IN_MEMORY8, 1); + BEGIN_RING(chan, kelvin, NV25_3D_UNK01AC, 1); OUT_RING (chan, chan->vram->handle); } - BEGIN_RING(chan, kelvin, NV20TCL_DMA_FENCE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_DMA_FENCE, 1); OUT_RING (chan, 0); BEGIN_RING(chan, kelvin, 0x1e98, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_NOTIFY, 1); + BEGIN_RING(chan, kelvin, NV01_GRAPH_NOTIFY, 1); OUT_RING (chan, 0); BEGIN_RING(chan, kelvin, 0x120, 3); @@ -134,197 +188,193 @@ nv20_hwctx_init(struct gl_context *ctx) OUT_RING (chan, 2); if (context_chipset(ctx) >= 0x25) { - BEGIN_RING(chan, kelvin, 0x022c, 2); - OUT_RING (chan, 0x280); - OUT_RING (chan, 0x07d28000); - BEGIN_RING(chan, kelvin, 0x1da4, 1); OUT_RING (chan, 0); } - BEGIN_RING(chan, kelvin, NV20TCL_RT_HORIZ, 2); + BEGIN_RING(chan, kelvin, NV20_3D_RT_HORIZ, 2); OUT_RING (chan, 0 << 16 | 0); OUT_RING (chan, 0 << 16 | 0); - BEGIN_RING(chan, kelvin, NV20TCL_ALPHA_FUNC_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_ALPHA_FUNC_ENABLE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_ALPHA_FUNC_FUNC, 2); - OUT_RING (chan, NV20TCL_ALPHA_FUNC_FUNC_ALWAYS); + BEGIN_RING(chan, kelvin, NV20_3D_ALPHA_FUNC_FUNC, 2); + OUT_RING (chan, NV20_3D_ALPHA_FUNC_FUNC_ALWAYS); OUT_RING (chan, 0); - for (i = 0; i < NV20TCL_TX_ENABLE__SIZE; i++) { - BEGIN_RING(chan, kelvin, NV20TCL_TX_ENABLE(i), 1); + for (i = 0; i < NV20_3D_TEX__LEN; i++) { + BEGIN_RING(chan, kelvin, NV20_3D_TEX_ENABLE(i), 1); OUT_RING (chan, 0); } - BEGIN_RING(chan, kelvin, NV20TCL_TX_SHADER_OP, 1); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_SHADER_OP, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_TX_SHADER_CULL_MODE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_SHADER_CULL_MODE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_RC_IN_ALPHA(0), 4); + BEGIN_RING(chan, kelvin, NV20_3D_RC_IN_ALPHA(0), 4); OUT_RING (chan, 0x30d410d0); OUT_RING (chan, 0); OUT_RING (chan, 0); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_RC_OUT_RGB(0), 4); + BEGIN_RING(chan, kelvin, NV20_3D_RC_OUT_RGB(0), 4); OUT_RING (chan, 0x00000c00); OUT_RING (chan, 0); OUT_RING (chan, 0); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_RC_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_RC_ENABLE, 1); OUT_RING (chan, 0x00011101); - BEGIN_RING(chan, kelvin, NV20TCL_RC_FINAL0, 2); + BEGIN_RING(chan, kelvin, NV20_3D_RC_FINAL0, 2); OUT_RING (chan, 0x130e0300); OUT_RING (chan, 0x0c091c80); - BEGIN_RING(chan, kelvin, NV20TCL_RC_OUT_ALPHA(0), 4); + BEGIN_RING(chan, kelvin, NV20_3D_RC_OUT_ALPHA(0), 4); OUT_RING (chan, 0x00000c00); OUT_RING (chan, 0); OUT_RING (chan, 0); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_RC_IN_RGB(0), 4); + BEGIN_RING(chan, kelvin, NV20_3D_RC_IN_RGB(0), 4); OUT_RING (chan, 0x20c400c0); OUT_RING (chan, 0); OUT_RING (chan, 0); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_RC_COLOR0, 2); + BEGIN_RING(chan, kelvin, NV20_3D_RC_COLOR0, 2); OUT_RING (chan, 0); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_RC_CONSTANT_COLOR0(0), 4); + BEGIN_RING(chan, kelvin, NV20_3D_RC_CONSTANT_COLOR0(0), 4); OUT_RING (chan, 0x035125a0); OUT_RING (chan, 0); OUT_RING (chan, 0x40002000); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_MULTISAMPLE_CONTROL, 1); + BEGIN_RING(chan, kelvin, NV20_3D_MULTISAMPLE_CONTROL, 1); OUT_RING (chan, 0xffff0000); - BEGIN_RING(chan, kelvin, NV20TCL_BLEND_FUNC_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_BLEND_FUNC_ENABLE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_DITHER_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_DITHER_ENABLE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_STENCIL_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_STENCIL_ENABLE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_BLEND_FUNC_SRC, 4); - OUT_RING (chan, NV20TCL_BLEND_FUNC_SRC_ONE); - OUT_RING (chan, NV20TCL_BLEND_FUNC_DST_ZERO); + BEGIN_RING(chan, kelvin, NV20_3D_BLEND_FUNC_SRC, 4); + OUT_RING (chan, NV20_3D_BLEND_FUNC_SRC_ONE); + OUT_RING (chan, NV20_3D_BLEND_FUNC_DST_ZERO); OUT_RING (chan, 0); - OUT_RING (chan, NV20TCL_BLEND_EQUATION_FUNC_ADD); - BEGIN_RING(chan, kelvin, NV20TCL_STENCIL_MASK, 7); + OUT_RING (chan, NV20_3D_BLEND_EQUATION_FUNC_ADD); + BEGIN_RING(chan, kelvin, NV20_3D_STENCIL_MASK, 7); OUT_RING (chan, 0xff); - OUT_RING (chan, NV20TCL_STENCIL_FUNC_FUNC_ALWAYS); + OUT_RING (chan, NV20_3D_STENCIL_FUNC_FUNC_ALWAYS); OUT_RING (chan, 0); OUT_RING (chan, 0xff); - OUT_RING (chan, NV20TCL_STENCIL_OP_FAIL_KEEP); - OUT_RING (chan, NV20TCL_STENCIL_OP_ZFAIL_KEEP); - OUT_RING (chan, NV20TCL_STENCIL_OP_ZPASS_KEEP); + OUT_RING (chan, NV20_3D_STENCIL_OP_FAIL_KEEP); + OUT_RING (chan, NV20_3D_STENCIL_OP_ZFAIL_KEEP); + OUT_RING (chan, NV20_3D_STENCIL_OP_ZPASS_KEEP); - BEGIN_RING(chan, kelvin, NV20TCL_COLOR_LOGIC_OP_ENABLE, 2); + BEGIN_RING(chan, kelvin, NV20_3D_COLOR_LOGIC_OP_ENABLE, 2); OUT_RING (chan, 0); - OUT_RING (chan, NV20TCL_COLOR_LOGIC_OP_OP_COPY); + OUT_RING (chan, NV20_3D_COLOR_LOGIC_OP_OP_COPY); BEGIN_RING(chan, kelvin, 0x17cc, 1); OUT_RING (chan, 0); if (context_chipset(ctx) >= 0x25) { BEGIN_RING(chan, kelvin, 0x1d84, 1); OUT_RING (chan, 1); } - BEGIN_RING(chan, kelvin, NV20TCL_LIGHTING_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_LIGHTING_ENABLE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_LIGHT_MODEL, 1); - OUT_RING (chan, NV20TCL_LIGHT_MODEL_VIEWER_NONLOCAL); - BEGIN_RING(chan, kelvin, NV20TCL_SEPARATE_SPECULAR_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_MODEL, 1); + OUT_RING (chan, NV20_3D_LIGHT_MODEL_VIEWER_NONLOCAL); + BEGIN_RING(chan, kelvin, NV20_3D_SEPARATE_SPECULAR_ENABLE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_LIGHT_MODEL_TWO_SIDE_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_MODEL_TWO_SIDE_ENABLE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_ENABLED_LIGHTS, 1); + BEGIN_RING(chan, kelvin, NV20_3D_ENABLED_LIGHTS, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_NORMALIZE_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_NORMALIZE_ENABLE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_POLYGON_STIPPLE_PATTERN(0), - NV20TCL_POLYGON_STIPPLE_PATTERN__SIZE); - for (i = 0; i < NV20TCL_POLYGON_STIPPLE_PATTERN__SIZE; i++) { + BEGIN_RING(chan, kelvin, NV20_3D_POLYGON_STIPPLE_PATTERN(0), + NV20_3D_POLYGON_STIPPLE_PATTERN__LEN); + for (i = 0; i < NV20_3D_POLYGON_STIPPLE_PATTERN__LEN; i++) { OUT_RING(chan, 0xffffffff); } - BEGIN_RING(chan, kelvin, NV20TCL_POLYGON_OFFSET_POINT_ENABLE, 3); + BEGIN_RING(chan, kelvin, NV20_3D_POLYGON_OFFSET_POINT_ENABLE, 3); OUT_RING (chan, 0); OUT_RING (chan, 0); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_DEPTH_FUNC, 1); - OUT_RING (chan, NV20TCL_DEPTH_FUNC_LESS); - BEGIN_RING(chan, kelvin, NV20TCL_DEPTH_WRITE_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_DEPTH_FUNC, 1); + OUT_RING (chan, NV20_3D_DEPTH_FUNC_LESS); + BEGIN_RING(chan, kelvin, NV20_3D_DEPTH_WRITE_ENABLE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_DEPTH_TEST_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_DEPTH_TEST_ENABLE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_POLYGON_OFFSET_FACTOR, 2); + BEGIN_RING(chan, kelvin, NV20_3D_POLYGON_OFFSET_FACTOR, 2); OUT_RINGf (chan, 0.0); OUT_RINGf (chan, 0.0); - BEGIN_RING(chan, kelvin, NV20TCL_DEPTH_UNK17D8, 1); + BEGIN_RING(chan, kelvin, NV20_3D_DEPTH_CLAMP, 1); OUT_RING (chan, 1); if (context_chipset(ctx) < 0x25) { BEGIN_RING(chan, kelvin, 0x1d84, 1); OUT_RING (chan, 3); } - BEGIN_RING(chan, kelvin, NV20TCL_POINT_SIZE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_POINT_SIZE, 1); if (context_chipset(ctx) >= 0x25) OUT_RINGf (chan, 1.0); else OUT_RING (chan, 8); if (context_chipset(ctx) >= 0x25) { - BEGIN_RING(chan, kelvin, NV20TCL_POINT_PARAMETERS_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_POINT_PARAMETERS_ENABLE, 1); OUT_RING (chan, 0); BEGIN_RING(chan, kelvin, 0x0a1c, 1); OUT_RING (chan, 0x800); } else { - BEGIN_RING(chan, kelvin, NV20TCL_POINT_PARAMETERS_ENABLE, 2); + BEGIN_RING(chan, kelvin, NV20_3D_POINT_PARAMETERS_ENABLE, 2); OUT_RING (chan, 0); OUT_RING (chan, 0); } - BEGIN_RING(chan, kelvin, NV20TCL_LINE_WIDTH, 1); + BEGIN_RING(chan, kelvin, NV20_3D_LINE_WIDTH, 1); OUT_RING (chan, 8); - BEGIN_RING(chan, kelvin, NV20TCL_LINE_SMOOTH_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_LINE_SMOOTH_ENABLE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_POLYGON_MODE_FRONT, 2); - OUT_RING (chan, NV20TCL_POLYGON_MODE_FRONT_FILL); - OUT_RING (chan, NV20TCL_POLYGON_MODE_BACK_FILL); - BEGIN_RING(chan, kelvin, NV20TCL_CULL_FACE, 2); - OUT_RING (chan, NV20TCL_CULL_FACE_BACK); - OUT_RING (chan, NV20TCL_FRONT_FACE_CCW); - BEGIN_RING(chan, kelvin, NV20TCL_POLYGON_SMOOTH_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_POLYGON_MODE_FRONT, 2); + OUT_RING (chan, NV20_3D_POLYGON_MODE_FRONT_FILL); + OUT_RING (chan, NV20_3D_POLYGON_MODE_BACK_FILL); + BEGIN_RING(chan, kelvin, NV20_3D_CULL_FACE, 2); + OUT_RING (chan, NV20_3D_CULL_FACE_BACK); + OUT_RING (chan, NV20_3D_FRONT_FACE_CCW); + BEGIN_RING(chan, kelvin, NV20_3D_POLYGON_SMOOTH_ENABLE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_CULL_FACE_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_CULL_FACE_ENABLE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_SHADE_MODEL, 1); - OUT_RING (chan, NV20TCL_SHADE_MODEL_SMOOTH); - BEGIN_RING(chan, kelvin, NV20TCL_POLYGON_STIPPLE_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_SHADE_MODEL, 1); + OUT_RING (chan, NV20_3D_SHADE_MODEL_SMOOTH); + BEGIN_RING(chan, kelvin, NV20_3D_POLYGON_STIPPLE_ENABLE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_TX_GEN_MODE_S(0), - 4 * NV20TCL_TX_GEN_MODE_S__SIZE); - for (i=0; i < 4 * NV20TCL_TX_GEN_MODE_S__SIZE; i++) + BEGIN_RING(chan, kelvin, NV20_3D_TEX_GEN_MODE(0,0), + 4 * NV20_3D_TEX_GEN_MODE__ESIZE); + for (i=0; i < 4 * NV20_3D_TEX_GEN_MODE__LEN; i++) OUT_RING(chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_FOG_EQUATION_CONSTANT, 3); + BEGIN_RING(chan, kelvin, NV20_3D_FOG_COEFF(0), 3); OUT_RINGf (chan, 1.5); OUT_RINGf (chan, -0.090168); OUT_RINGf (chan, 0.0); - BEGIN_RING(chan, kelvin, NV20TCL_FOG_MODE, 2); - OUT_RING (chan, NV20TCL_FOG_MODE_EXP_SIGNED); - OUT_RING (chan, NV20TCL_FOG_COORD_FOG); - BEGIN_RING(chan, kelvin, NV20TCL_FOG_ENABLE, 2); + BEGIN_RING(chan, kelvin, NV20_3D_FOG_MODE, 2); + OUT_RING (chan, NV20_3D_FOG_MODE_EXP_SIGNED); + OUT_RING (chan, NV20_3D_FOG_COORD_FOG); + BEGIN_RING(chan, kelvin, NV20_3D_FOG_ENABLE, 2); OUT_RING (chan, 0); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_ENGINE, 1); - OUT_RING (chan, NV20TCL_ENGINE_FIXED); + BEGIN_RING(chan, kelvin, NV20_3D_ENGINE, 1); + OUT_RING (chan, NV20_3D_ENGINE_FIXED); - for (i = 0; i < NV20TCL_TX_MATRIX_ENABLE__SIZE; i++) { - BEGIN_RING(chan, kelvin, NV20TCL_TX_MATRIX_ENABLE(i), 1); + for (i = 0; i < NV20_3D_TEX_MATRIX_ENABLE__LEN; i++) { + BEGIN_RING(chan, kelvin, NV20_3D_TEX_MATRIX_ENABLE(i), 1); OUT_RING (chan, 0); } - BEGIN_RING(chan, kelvin, NV20TCL_VTX_ATTR_4F_X(1), 4 * 15); + BEGIN_RING(chan, kelvin, NV20_3D_VERTEX_ATTR_4F_X(1), 4 * 15); OUT_RINGf(chan, 1.0); OUT_RINGf(chan, 0.0); OUT_RINGf(chan, 0.0); @@ -344,24 +394,24 @@ nv20_hwctx_init(struct gl_context *ctx) OUT_RINGf(chan, 1.0); } - BEGIN_RING(chan, kelvin, NV20TCL_EDGEFLAG_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_EDGEFLAG_ENABLE, 1); OUT_RING (chan, 1); - BEGIN_RING(chan, kelvin, NV20TCL_COLOR_MASK, 1); + BEGIN_RING(chan, kelvin, NV20_3D_COLOR_MASK, 1); OUT_RING (chan, 0x00010101); - BEGIN_RING(chan, kelvin, NV20TCL_CLEAR_VALUE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_CLEAR_VALUE, 1); OUT_RING (chan, 0); - BEGIN_RING(chan, kelvin, NV20TCL_DEPTH_RANGE_NEAR, 2); + BEGIN_RING(chan, kelvin, NV20_3D_DEPTH_RANGE_NEAR, 2); OUT_RINGf (chan, 0.0); OUT_RINGf (chan, 16777216.0); - BEGIN_RING(chan, kelvin, NV20TCL_VIEWPORT_TRANSLATE_X, 4); + BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_TRANSLATE_X, 4); OUT_RINGf (chan, 0.0); OUT_RINGf (chan, 0.0); OUT_RINGf (chan, 0.0); OUT_RINGf (chan, 16777215.0); - BEGIN_RING(chan, kelvin, NV20TCL_VIEWPORT_SCALE_X, 4); + BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_SCALE_X, 4); OUT_RINGf (chan, 0.0); OUT_RINGf (chan, 0.0); OUT_RINGf (chan, 16777215.0 * 0.5); @@ -376,7 +426,8 @@ nv20_context_destroy(struct gl_context *ctx) struct nouveau_context *nctx = to_nouveau_context(ctx); nv04_surface_takedown(ctx); - nv20_render_destroy(ctx); + nv20_swtnl_destroy(ctx); + nv20_vbo_destroy(ctx); nouveau_grobj_free(&nctx->hw.eng3d); @@ -410,6 +461,7 @@ nv20_context_create(struct nouveau_screen *screen, const struct gl_config *visua ctx->Const.MaxTextureUnits = NV20_TEXTURE_UNITS; ctx->Const.MaxTextureMaxAnisotropy = 8; ctx->Const.MaxTextureLodBias = 15; + ctx->Driver.Clear = nv20_clear; /* 2D engine. */ ret = nv04_surface_init(ctx); @@ -418,9 +470,9 @@ nv20_context_create(struct nouveau_screen *screen, const struct gl_config *visua /* 3D engine. */ if (context_chipset(ctx) >= 0x25) - kelvin_class = NV25TCL; + kelvin_class = NV25_3D; else - kelvin_class = NV20TCL; + kelvin_class = NV20_3D; ret = nouveau_grobj_alloc(context_chan(ctx), 0xbeef0001, kelvin_class, &nctx->hw.eng3d); @@ -428,7 +480,8 @@ nv20_context_create(struct nouveau_screen *screen, const struct gl_config *visua goto fail; nv20_hwctx_init(ctx); - nv20_render_init(ctx); + nv20_vbo_init(ctx); + nv20_swtnl_init(ctx); return ctx; diff --git a/src/mesa/drivers/dri/nouveau/nv20_driver.h b/src/mesa/drivers/dri/nouveau/nv20_driver.h index 7fbe6ccfa6..f2a6097b93 100644 --- a/src/mesa/drivers/dri/nouveau/nv20_driver.h +++ b/src/mesa/drivers/dri/nouveau/nv20_driver.h @@ -39,10 +39,16 @@ extern const struct nouveau_driver nv20_driver; /* nv20_render.c */ void -nv20_render_init(struct gl_context *ctx); +nv20_vbo_init(struct gl_context *ctx); void -nv20_render_destroy(struct gl_context *ctx); +nv20_vbo_destroy(struct gl_context *ctx); + +void +nv20_swtnl_init(struct gl_context *ctx); + +void +nv20_swtnl_destroy(struct gl_context *ctx); /* nv20_state_fb.c */ void diff --git a/src/mesa/drivers/dri/nouveau/nv20_render.c b/src/mesa/drivers/dri/nouveau/nv20_render.c index 6b66854462..2bdc85cda4 100644 --- a/src/mesa/drivers/dri/nouveau/nv20_render.c +++ b/src/mesa/drivers/dri/nouveau/nv20_render.c @@ -26,60 +26,60 @@ #include "nouveau_driver.h" #include "nouveau_context.h" -#include "nouveau_class.h" +#include "nv20_3d.xml.h" #include "nv20_driver.h" #define NUM_VERTEX_ATTRS 16 static void -nv20_emit_material(struct gl_context *ctx, struct nouveau_array_state *a, +nv20_emit_material(struct gl_context *ctx, struct nouveau_array *a, const void *v); /* Vertex attribute format. */ static struct nouveau_attr_info nv20_vertex_attrs[VERT_ATTRIB_MAX] = { [VERT_ATTRIB_POS] = { .vbo_index = 0, - .imm_method = NV20TCL_VERTEX_POS_4F_X, + .imm_method = NV20_3D_VERTEX_POS_4F_X, .imm_fields = 4, }, [VERT_ATTRIB_NORMAL] = { .vbo_index = 2, - .imm_method = NV20TCL_VERTEX_NOR_3F_X, + .imm_method = NV20_3D_VERTEX_NOR_3F_X, .imm_fields = 3, }, [VERT_ATTRIB_COLOR0] = { .vbo_index = 3, - .imm_method = NV20TCL_VERTEX_COL_4F_X, + .imm_method = NV20_3D_VERTEX_COL_4F, .imm_fields = 4, }, [VERT_ATTRIB_COLOR1] = { .vbo_index = 4, - .imm_method = NV20TCL_VERTEX_COL2_3F_X, + .imm_method = NV20_3D_VERTEX_COL2_3F, .imm_fields = 3, }, [VERT_ATTRIB_FOG] = { .vbo_index = 5, - .imm_method = NV20TCL_VERTEX_FOG_1F, + .imm_method = NV20_3D_VERTEX_FOG_1F, .imm_fields = 1, }, [VERT_ATTRIB_TEX0] = { .vbo_index = 9, - .imm_method = NV20TCL_VERTEX_TX0_4F_S, + .imm_method = NV20_3D_VERTEX_TX0_4F_S, .imm_fields = 4, }, [VERT_ATTRIB_TEX1] = { .vbo_index = 10, - .imm_method = NV20TCL_VERTEX_TX1_4F_S, + .imm_method = NV20_3D_VERTEX_TX1_4F_S, .imm_fields = 4, }, [VERT_ATTRIB_TEX2] = { .vbo_index = 11, - .imm_method = NV20TCL_VERTEX_TX2_4F_S, + .imm_method = NV20_3D_VERTEX_TX2_4F_S, .imm_fields = 4, }, [VERT_ATTRIB_TEX3] = { .vbo_index = 12, - .imm_method = NV20TCL_VERTEX_TX3_4F_S, + .imm_method = NV20_3D_VERTEX_TX3_4F_S, .imm_fields = 4, }, [VERT_ATTRIB_GENERIC0] = { @@ -119,11 +119,11 @@ get_hw_format(int type) { switch (type) { case GL_FLOAT: - return NV20TCL_VTXFMT_TYPE_FLOAT; + return NV20_3D_VTXBUF_FMT_TYPE_FLOAT; case GL_UNSIGNED_SHORT: - return NV20TCL_VTXFMT_TYPE_USHORT; + return NV20_3D_VTXBUF_FMT_TYPE_USHORT; case GL_UNSIGNED_BYTE: - return NV20TCL_VTXFMT_TYPE_UBYTE; + return NV20_3D_VTXBUF_FMT_TYPE_UBYTE; default: assert(0); } @@ -135,13 +135,11 @@ nv20_render_set_format(struct gl_context *ctx) struct nouveau_render_state *render = to_render_state(ctx); struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *kelvin = context_eng3d(ctx); - int i, hw_format; - - for (i = 0; i < NUM_VERTEX_ATTRS; i++) { - int attr = render->map[i]; + int i, attr, hw_format; + FOR_EACH_ATTR(render, i, attr) { if (attr >= 0) { - struct nouveau_array_state *a = &render->attrs[attr]; + struct nouveau_array *a = &render->attrs[attr]; hw_format = a->stride << 8 | a->fields << 4 | @@ -149,10 +147,10 @@ nv20_render_set_format(struct gl_context *ctx) } else { /* Unused attribute. */ - hw_format = NV10TCL_VTXFMT_TYPE_FLOAT; + hw_format = NV20_3D_VTXBUF_FMT_TYPE_FLOAT; } - BEGIN_RING(chan, kelvin, NV20TCL_VTXFMT(i), 1); + BEGIN_RING(chan, kelvin, NV20_3D_VTXBUF_FMT(i), 1); OUT_RING(chan, hw_format); } } @@ -162,57 +160,53 @@ nv20_render_bind_vertices(struct gl_context *ctx) { struct nouveau_render_state *render = to_render_state(ctx); struct nouveau_bo_context *bctx = context_bctx(ctx, VERTEX); - struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *kelvin = context_eng3d(ctx); - int i; + int i, attr; - for (i = 0; i < NUM_VERTEX_ATTRS; i++) { - int attr = render->map[i]; + FOR_EACH_BOUND_ATTR(render, i, attr) { + struct nouveau_array *a = &render->attrs[attr]; - if (attr >= 0) { - struct nouveau_array_state *a = &render->attrs[attr]; - - nouveau_bo_mark(bctx, kelvin, - NV20TCL_VTXBUF_ADDRESS(i), - a->bo, a->offset, 0, - 0, NV20TCL_VTXBUF_ADDRESS_DMA1, - NOUVEAU_BO_LOW | NOUVEAU_BO_OR | - NOUVEAU_BO_GART | NOUVEAU_BO_RD); - } + nouveau_bo_mark(bctx, kelvin, + NV20_3D_VTXBUF_OFFSET(i), + a->bo, a->offset, 0, + 0, NV20_3D_VTXBUF_OFFSET_DMA1, + NOUVEAU_BO_LOW | NOUVEAU_BO_OR | + NOUVEAU_BO_GART | NOUVEAU_BO_RD); } - - BEGIN_RING(chan, kelvin, NV20TCL_VTX_CACHE_INVALIDATE, 1); - OUT_RING(chan, 0); } /* Vertex array rendering defs. */ #define RENDER_LOCALS(ctx) \ struct nouveau_grobj *kelvin = context_eng3d(ctx) +#define BATCH_VALIDATE() \ + BEGIN_RING(chan, kelvin, NV20_3D_VTXBUF_VALIDATE, 1); \ + OUT_RING(chan, 0) + #define BATCH_BEGIN(prim) \ - BEGIN_RING(chan, kelvin, NV20TCL_VERTEX_BEGIN_END, 1); \ + BEGIN_RING(chan, kelvin, NV20_3D_VERTEX_BEGIN_END, 1); \ OUT_RING(chan, prim) #define BATCH_END() \ - BEGIN_RING(chan, kelvin, NV20TCL_VERTEX_BEGIN_END, 1); \ + BEGIN_RING(chan, kelvin, NV20_3D_VERTEX_BEGIN_END, 1); \ OUT_RING(chan, 0) #define MAX_PACKET 0x400 #define MAX_OUT_L 0x100 #define BATCH_PACKET_L(n) \ - BEGIN_RING_NI(chan, kelvin, NV20TCL_VB_VERTEX_BATCH, n) + BEGIN_RING_NI(chan, kelvin, NV20_3D_VTXBUF_BATCH, n) #define BATCH_OUT_L(i, n) \ OUT_RING(chan, ((n) - 1) << 24 | (i)) #define MAX_OUT_I16 0x2 #define BATCH_PACKET_I16(n) \ - BEGIN_RING_NI(chan, kelvin, NV20TCL_VB_ELEMENT_U16, n) + BEGIN_RING_NI(chan, kelvin, NV20_3D_VTXBUF_ELEMENT_U16, n) #define BATCH_OUT_I16(i0, i1) \ OUT_RING(chan, (i1) << 16 | (i0)) #define MAX_OUT_I32 0x1 #define BATCH_PACKET_I32(n) \ - BEGIN_RING_NI(chan, kelvin, NV20TCL_VB_ELEMENT_U32, n) + BEGIN_RING_NI(chan, kelvin, NV20_3D_VTXBUF_ELEMENT_U32, n) #define BATCH_OUT_I32(i) \ OUT_RING(chan, i) @@ -223,3 +217,5 @@ nv20_render_bind_vertices(struct gl_context *ctx) #define TAG(x) nv20_##x #include "nouveau_render_t.c" +#include "nouveau_vbo_t.c" +#include "nouveau_swtnl_t.c" diff --git a/src/mesa/drivers/dri/nouveau/nv20_state_fb.c b/src/mesa/drivers/dri/nouveau/nv20_state_fb.c index 7822ca2a09..cbde74e4fc 100644 --- a/src/mesa/drivers/dri/nouveau/nv20_state_fb.c +++ b/src/mesa/drivers/dri/nouveau/nv20_state_fb.c @@ -29,7 +29,7 @@ #include "nouveau_fbo.h" #include "nouveau_gldefs.h" #include "nouveau_util.h" -#include "nouveau_class.h" +#include "nv20_3d.xml.h" #include "nv20_driver.h" static inline unsigned @@ -37,20 +37,45 @@ get_rt_format(gl_format format) { switch (format) { case MESA_FORMAT_XRGB8888: - return 0x05; + return NV20_3D_RT_FORMAT_COLOR_X8R8G8B8; case MESA_FORMAT_ARGB8888: - return 0x08; + return NV20_3D_RT_FORMAT_COLOR_A8R8G8B8; case MESA_FORMAT_RGB565: - return 0x03; + return NV20_3D_RT_FORMAT_COLOR_R5G6B5; case MESA_FORMAT_Z16: - return 0x10; + return NV20_3D_RT_FORMAT_DEPTH_Z16; case MESA_FORMAT_Z24_S8: - return 0x20; + return NV20_3D_RT_FORMAT_DEPTH_Z24S8; default: assert(0); } } +static void +setup_hierz_buffer(struct gl_context *ctx) +{ + struct nouveau_channel *chan = context_chan(ctx); + struct nouveau_grobj *kelvin = 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(context_dev(ctx), NOUVEAU_BO_VRAM, 0, size, + &nfb->hierz.bo); + } + + BEGIN_RING(chan, kelvin, NV25_3D_HIERZ_PITCH, 1); + OUT_RING(chan, pitch); + + nouveau_bo_markl(bctx, kelvin, NV25_3D_HIERZ_OFFSET, nfb->hierz.bo, + 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR); +} + void nv20_emit_framebuffer(struct gl_context *ctx, int emit) { @@ -59,7 +84,7 @@ nv20_emit_framebuffer(struct gl_context *ctx, int emit) struct nouveau_bo_context *bctx = context_bctx(ctx, FRAMEBUFFER); struct gl_framebuffer *fb = ctx->DrawBuffer; struct nouveau_surface *s; - unsigned rt_format = NV20TCL_RT_FORMAT_TYPE_LINEAR; + unsigned rt_format = NV20_3D_RT_FORMAT_TYPE_LINEAR; unsigned rt_pitch = 0, zeta_pitch = 0; unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR; @@ -74,7 +99,7 @@ nv20_emit_framebuffer(struct gl_context *ctx, int emit) rt_format |= get_rt_format(s->format); rt_pitch = s->pitch; - nouveau_bo_markl(bctx, kelvin, NV20TCL_COLOR_OFFSET, + nouveau_bo_markl(bctx, kelvin, NV20_3D_COLOR_OFFSET, s->bo, 0, bo_flags); } @@ -86,14 +111,17 @@ nv20_emit_framebuffer(struct gl_context *ctx, int emit) rt_format |= get_rt_format(s->format); zeta_pitch = s->pitch; - nouveau_bo_markl(bctx, kelvin, NV20TCL_ZETA_OFFSET, + nouveau_bo_markl(bctx, kelvin, NV20_3D_ZETA_OFFSET, s->bo, 0, bo_flags); + + if (context_chipset(ctx) >= 0x25) + setup_hierz_buffer(ctx); } else { rt_format |= get_rt_format(MESA_FORMAT_Z24_S8); zeta_pitch = rt_pitch; } - BEGIN_RING(chan, kelvin, NV20TCL_RT_FORMAT, 2); + BEGIN_RING(chan, kelvin, NV20_3D_RT_FORMAT, 2); OUT_RING(chan, rt_format); OUT_RING(chan, zeta_pitch << 16 | rt_pitch); @@ -112,12 +140,12 @@ nv20_emit_viewport(struct gl_context *ctx, int emit) get_viewport_translate(ctx, a); - BEGIN_RING(chan, kelvin, NV20TCL_VIEWPORT_TRANSLATE_X, 4); + BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_TRANSLATE_X, 4); OUT_RINGp(chan, a, 4); - BEGIN_RING(chan, kelvin, NV20TCL_VIEWPORT_CLIP_HORIZ(0), 1); + BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_CLIP_HORIZ(0), 1); OUT_RING(chan, (fb->Width - 1) << 16); - BEGIN_RING(chan, kelvin, NV20TCL_VIEWPORT_CLIP_VERT(0), 1); + BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_CLIP_VERT(0), 1); OUT_RING(chan, (fb->Height - 1) << 16); context_dirty(ctx, PROJECTION); diff --git a/src/mesa/drivers/dri/nouveau/nv20_state_frag.c b/src/mesa/drivers/dri/nouveau/nv20_state_frag.c index f9212d8b39..0624de442b 100644 --- a/src/mesa/drivers/dri/nouveau/nv20_state_frag.c +++ b/src/mesa/drivers/dri/nouveau/nv20_state_frag.c @@ -26,7 +26,7 @@ #include "nouveau_driver.h" #include "nouveau_context.h" -#include "nouveau_class.h" +#include "nv20_3d.xml.h" #include "nv10_driver.h" #include "nv20_driver.h" @@ -40,15 +40,15 @@ nv20_emit_tex_env(struct gl_context *ctx, int emit) nv10_get_general_combiner(ctx, i, &a_in, &a_out, &c_in, &c_out, &k); - BEGIN_RING(chan, kelvin, NV20TCL_RC_IN_ALPHA(i), 1); + BEGIN_RING(chan, kelvin, NV20_3D_RC_IN_ALPHA(i), 1); OUT_RING(chan, a_in); - BEGIN_RING(chan, kelvin, NV20TCL_RC_OUT_ALPHA(i), 1); + BEGIN_RING(chan, kelvin, NV20_3D_RC_OUT_ALPHA(i), 1); OUT_RING(chan, a_out); - BEGIN_RING(chan, kelvin, NV20TCL_RC_IN_RGB(i), 1); + BEGIN_RING(chan, kelvin, NV20_3D_RC_IN_RGB(i), 1); OUT_RING(chan, c_in); - BEGIN_RING(chan, kelvin, NV20TCL_RC_OUT_RGB(i), 1); + BEGIN_RING(chan, kelvin, NV20_3D_RC_OUT_RGB(i), 1); OUT_RING(chan, c_out); - BEGIN_RING(chan, kelvin, NV20TCL_RC_CONSTANT_COLOR0(i), 1); + BEGIN_RING(chan, kelvin, NV20_3D_RC_CONSTANT_COLOR0(i), 1); OUT_RING(chan, k); context_dirty(ctx, FRAG); @@ -64,10 +64,10 @@ nv20_emit_frag(struct gl_context *ctx, int emit) nv10_get_final_combiner(ctx, &in, &n); - BEGIN_RING(chan, kelvin, NV20TCL_RC_FINAL0, 2); + BEGIN_RING(chan, kelvin, NV20_3D_RC_FINAL0, 2); OUT_RING(chan, in); OUT_RING(chan, in >> 32); - BEGIN_RING(chan, kelvin, NV20TCL_RC_ENABLE, 1); + BEGIN_RING(chan, kelvin, NV20_3D_RC_ENABLE, 1); OUT_RING(chan, n); } diff --git a/src/mesa/drivers/dri/nouveau/nv20_state_polygon.c b/src/mesa/drivers/dri/nouveau/nv20_state_polygon.c index a6e237f8c4..85f30dc4d4 100644 --- a/src/mesa/drivers/dri/nouveau/nv20_state_polygon.c +++ b/src/mesa/drivers/dri/nouveau/nv20_state_polygon.c @@ -27,7 +27,7 @@ #include "nouveau_driver.h" #include "nouveau_context.h" #include "nouveau_gldefs.h" -#include "nouveau_class.h" +#include "nv20_3d.xml.h" #include "nv20_driver.h" void @@ -36,7 +36,7 @@ nv20_emit_point_mode(struct gl_context *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); + BEGIN_RING(chan, kelvin, NV20_3D_POINT_SIZE, 1); if (context_chipset(ctx) >= 0x25) OUT_RINGf(chan, ctx->Point.Size); else diff --git a/src/mesa/drivers/dri/nouveau/nv20_state_raster.c b/src/mesa/drivers/dri/nouveau/nv20_state_raster.c index 0fc7a3259d..3fb4ecae89 100644 --- a/src/mesa/drivers/dri/nouveau/nv20_state_raster.c +++ b/src/mesa/drivers/dri/nouveau/nv20_state_raster.c @@ -27,7 +27,8 @@ #include "nouveau_driver.h" #include "nouveau_context.h" #include "nouveau_gldefs.h" -#include "nouveau_class.h" +#include "nouveau_util.h" +#include "nv20_3d.xml.h" #include "nv20_driver.h" void @@ -36,7 +37,7 @@ nv20_emit_logic_opcode(struct gl_context *ctx, int emit) struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *kelvin = context_eng3d(ctx); - BEGIN_RING(chan, kelvin, NV20TCL_COLOR_LOGIC_OP_ENABLE, 2); - OUT_RING(chan, ctx->Color.ColorLogicOpEnabled ? 1 : 0); + BEGIN_RING(chan, kelvin, NV20_3D_COLOR_LOGIC_OP_ENABLE, 2); + OUT_RINGb(chan, ctx->Color.ColorLogicOpEnabled); OUT_RING(chan, nvgl_logicop_func(ctx->Color.LogicOp)); } diff --git a/src/mesa/drivers/dri/nouveau/nv20_state_tex.c b/src/mesa/drivers/dri/nouveau/nv20_state_tex.c index cfff1fe839..c362aca0fd 100644 --- a/src/mesa/drivers/dri/nouveau/nv20_state_tex.c +++ b/src/mesa/drivers/dri/nouveau/nv20_state_tex.c @@ -28,14 +28,10 @@ #include "nouveau_context.h" #include "nouveau_gldefs.h" #include "nouveau_texture.h" -#include "nouveau_class.h" +#include "nv20_3d.xml.h" #include "nouveau_util.h" #include "nv20_driver.h" -#define TX_GEN_MODE(i, j) (NV20TCL_TX_GEN_MODE_S(i) + 4 * (j)) -#define TX_GEN_COEFF(i, j) (NV20TCL_TX_GEN_COEFF_S_A(i) + 16 * (j)) -#define TX_MATRIX(i) (NV20TCL_TX0_MATRIX(0) + 64 * (i)) - void nv20_emit_tex_gen(struct gl_context *ctx, int emit) { @@ -52,15 +48,16 @@ nv20_emit_tex_gen(struct gl_context *ctx, int emit) float *k = get_texgen_coeff(coord); if (k) { - BEGIN_RING(chan, kelvin, TX_GEN_COEFF(i, j), 4); + BEGIN_RING(chan, kelvin, + NV20_3D_TEX_GEN_COEFF(i, j), 4); OUT_RINGp(chan, k, 4); } - BEGIN_RING(chan, kelvin, TX_GEN_MODE(i, j), 1); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_GEN_MODE(i, j), 1); OUT_RING(chan, nvgl_texgen_mode(coord->Mode)); } else { - BEGIN_RING(chan, kelvin, TX_GEN_MODE(i, j), 1); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_GEN_MODE(i, j), 1); OUT_RING(chan, 0); } } @@ -76,14 +73,14 @@ nv20_emit_tex_mat(struct gl_context *ctx, int emit) if (nctx->fallback == HWTNL && (ctx->Texture._TexMatEnabled & 1 << i)) { - BEGIN_RING(chan, kelvin, NV20TCL_TX_MATRIX_ENABLE(i), 1); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_MATRIX_ENABLE(i), 1); OUT_RING(chan, 1); - BEGIN_RING(chan, kelvin, TX_MATRIX(i), 16); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_MATRIX(i,0), 16); OUT_RINGm(chan, ctx->TextureMatrixStack[i].Top->m); } else { - BEGIN_RING(chan, kelvin, NV20TCL_TX_MATRIX_ENABLE(i), 1); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_MATRIX_ENABLE(i), 1); OUT_RING(chan, 0); } } @@ -93,29 +90,29 @@ get_tex_format_pot(struct gl_texture_image *ti) { switch (ti->TexFormat) { case MESA_FORMAT_ARGB8888: - return NV20TCL_TX_FORMAT_FORMAT_A8R8G8B8; + return NV20_3D_TEX_FORMAT_FORMAT_A8R8G8B8; case MESA_FORMAT_ARGB1555: - return NV20TCL_TX_FORMAT_FORMAT_A1R5G5B5; + return NV20_3D_TEX_FORMAT_FORMAT_A1R5G5B5; case MESA_FORMAT_ARGB4444: - return NV20TCL_TX_FORMAT_FORMAT_A4R4G4B4; + return NV20_3D_TEX_FORMAT_FORMAT_A4R4G4B4; case MESA_FORMAT_XRGB8888: - return NV20TCL_TX_FORMAT_FORMAT_X8R8G8B8; + return NV20_3D_TEX_FORMAT_FORMAT_X8R8G8B8; case MESA_FORMAT_RGB565: - return NV20TCL_TX_FORMAT_FORMAT_R5G6B5; + return NV20_3D_TEX_FORMAT_FORMAT_R5G6B5; case MESA_FORMAT_A8: case MESA_FORMAT_I8: - return NV20TCL_TX_FORMAT_FORMAT_A8; + return NV20_3D_TEX_FORMAT_FORMAT_I8; case MESA_FORMAT_L8: - return NV20TCL_TX_FORMAT_FORMAT_L8; + return NV20_3D_TEX_FORMAT_FORMAT_L8; case MESA_FORMAT_CI8: - return NV20TCL_TX_FORMAT_FORMAT_INDEX8; + return NV20_3D_TEX_FORMAT_FORMAT_INDEX8; default: assert(0); @@ -127,26 +124,26 @@ get_tex_format_rect(struct gl_texture_image *ti) { switch (ti->TexFormat) { case MESA_FORMAT_ARGB8888: - return NV20TCL_TX_FORMAT_FORMAT_A8R8G8B8_RECT; + return NV20_3D_TEX_FORMAT_FORMAT_A8R8G8B8_RECT; case MESA_FORMAT_ARGB1555: - return NV20TCL_TX_FORMAT_FORMAT_A1R5G5B5_RECT; + return NV20_3D_TEX_FORMAT_FORMAT_A1R5G5B5_RECT; case MESA_FORMAT_ARGB4444: - return NV20TCL_TX_FORMAT_FORMAT_A4R4G4B4_RECT; + return NV20_3D_TEX_FORMAT_FORMAT_A4R4G4B4_RECT; case MESA_FORMAT_XRGB8888: - return NV20TCL_TX_FORMAT_FORMAT_R8G8B8_RECT; + return NV20_3D_TEX_FORMAT_FORMAT_R8G8B8_RECT; case MESA_FORMAT_RGB565: - return NV20TCL_TX_FORMAT_FORMAT_R5G6B5_RECT; + return NV20_3D_TEX_FORMAT_FORMAT_R5G6B5_RECT; case MESA_FORMAT_L8: - return NV20TCL_TX_FORMAT_FORMAT_L8_RECT; + return NV20_3D_TEX_FORMAT_FORMAT_L8_RECT; case MESA_FORMAT_A8: case MESA_FORMAT_I8: - return NV20TCL_TX_FORMAT_FORMAT_A8_RECT; + return NV20_3D_TEX_FORMAT_FORMAT_I8_RECT; default: assert(0); @@ -167,7 +164,7 @@ nv20_emit_tex_obj(struct gl_context *ctx, int emit) uint32_t tx_format, tx_filter, tx_wrap, tx_enable; if (!ctx->Texture.Unit[i]._ReallyEnabled) { - BEGIN_RING(chan, kelvin, NV20TCL_TX_ENABLE(i), 1); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_ENABLE(i), 1); OUT_RING(chan, 0); context_dirty(ctx, TEX_SHADER); @@ -185,8 +182,8 @@ nv20_emit_tex_obj(struct gl_context *ctx, int emit) tx_format = ti->DepthLog2 << 28 | ti->HeightLog2 << 24 | ti->WidthLog2 << 20 - | NV20TCL_TX_FORMAT_DIMS_2D - | NV20TCL_TX_FORMAT_NO_BORDER + | NV20_3D_TEX_FORMAT_DIMS_2D + | NV20_3D_TEX_FORMAT_NO_BORDER | 1 << 16; tx_wrap = nvgl_wrap_mode(t->WrapR) << 16 @@ -197,13 +194,13 @@ nv20_emit_tex_obj(struct gl_context *ctx, int emit) | nvgl_filter_mode(t->MinFilter) << 16 | 2 << 12; - tx_enable = NV20TCL_TX_ENABLE_ENABLE + tx_enable = NV20_3D_TEX_ENABLE_ENABLE | log2i(t->MaxAnisotropy) << 4; if (t->Target == GL_TEXTURE_RECTANGLE) { - BEGIN_RING(chan, kelvin, NV20TCL_TX_NPOT_PITCH(i), 1); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_NPOT_PITCH(i), 1); OUT_RING(chan, s->pitch << 16); - BEGIN_RING(chan, kelvin, NV20TCL_TX_NPOT_SIZE(i), 1); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_NPOT_SIZE(i), 1); OUT_RING(chan, s->width << 16 | s->height); tx_format |= get_tex_format_rect(ti); @@ -222,29 +219,29 @@ nv20_emit_tex_obj(struct gl_context *ctx, int emit) lod_min = CLAMP(lod_min, 0, 15); lod_bias = CLAMP(lod_bias, 0, 15); - tx_format |= NV20TCL_TX_FORMAT_MIPMAP; + tx_format |= NV20_3D_TEX_FORMAT_MIPMAP; tx_filter |= lod_bias << 8; tx_enable |= lod_min << 26 | lod_max << 14; } /* Write it to the hardware. */ - nouveau_bo_mark(bctx, kelvin, NV20TCL_TX_FORMAT(i), + nouveau_bo_mark(bctx, kelvin, NV20_3D_TEX_FORMAT(i), s->bo, tx_format, 0, - NV20TCL_TX_FORMAT_DMA0, - NV20TCL_TX_FORMAT_DMA1, + NV20_3D_TEX_FORMAT_DMA0, + NV20_3D_TEX_FORMAT_DMA1, bo_flags | NOUVEAU_BO_OR); - nouveau_bo_markl(bctx, kelvin, NV20TCL_TX_OFFSET(i), + nouveau_bo_markl(bctx, kelvin, NV20_3D_TEX_OFFSET(i), s->bo, s->offset, bo_flags); - BEGIN_RING(chan, kelvin, NV20TCL_TX_WRAP(i), 1); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_WRAP(i), 1); OUT_RING(chan, tx_wrap); - BEGIN_RING(chan, kelvin, NV20TCL_TX_FILTER(i), 1); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_FILTER(i), 1); OUT_RING(chan, tx_filter); - BEGIN_RING(chan, kelvin, NV20TCL_TX_ENABLE(i), 1); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_ENABLE(i), 1); OUT_RING(chan, tx_enable); context_dirty(ctx, TEX_SHADER); @@ -262,9 +259,9 @@ nv20_emit_tex_shader(struct gl_context *ctx, int emit) if (!ctx->Texture.Unit[i]._ReallyEnabled) continue; - tx_shader_op |= NV20TCL_TX_SHADER_OP_TX0_TEXTURE_2D << 5 * i; + tx_shader_op |= NV20_3D_TEX_SHADER_OP_TX0_TEXTURE_2D << 5 * i; } - BEGIN_RING(chan, kelvin, NV20TCL_TX_SHADER_OP, 1); + BEGIN_RING(chan, kelvin, NV20_3D_TEX_SHADER_OP, 1); OUT_RING(chan, tx_shader_op); } diff --git a/src/mesa/drivers/dri/nouveau/nv20_state_tnl.c b/src/mesa/drivers/dri/nouveau/nv20_state_tnl.c index b65cd9ad87..4677198dd0 100644 --- a/src/mesa/drivers/dri/nouveau/nv20_state_tnl.c +++ b/src/mesa/drivers/dri/nouveau/nv20_state_tnl.c @@ -28,31 +28,31 @@ #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) ? NV20TCL_LIGHT_MODEL_BACK_AMBIENT_R : \ - NV20TCL_LIGHT_MODEL_FRONT_AMBIENT_R) + ((side) ? NV20_3D_LIGHT_MODEL_BACK_AMBIENT_R : \ + NV20_3D_LIGHT_MODEL_FRONT_AMBIENT_R) #define LIGHT_AMBIENT_R(side, i) \ - ((side) ? NV20TCL_LIGHT_BACK_AMBIENT_R(i) : \ - NV20TCL_LIGHT_FRONT_AMBIENT_R(i)) + ((side) ? NV20_3D_LIGHT_BACK_AMBIENT_R(i) : \ + NV20_3D_LIGHT_FRONT_AMBIENT_R(i)) #define LIGHT_DIFFUSE_R(side, i) \ - ((side) ? NV20TCL_LIGHT_BACK_DIFFUSE_R(i) : \ - NV20TCL_LIGHT_FRONT_DIFFUSE_R(i)) + ((side) ? NV20_3D_LIGHT_BACK_DIFFUSE_R(i) : \ + NV20_3D_LIGHT_FRONT_DIFFUSE_R(i)) #define LIGHT_SPECULAR_R(side, i) \ - ((side) ? NV20TCL_LIGHT_BACK_SPECULAR_R(i) : \ - NV20TCL_LIGHT_FRONT_SPECULAR_R(i)) + ((side) ? NV20_3D_LIGHT_BACK_SPECULAR_R(i) : \ + NV20_3D_LIGHT_FRONT_SPECULAR_R(i)) #define MATERIAL_FACTOR_R(side) \ - ((side) ? NV20TCL_MATERIAL_FACTOR_BACK_R : \ - NV20TCL_MATERIAL_FACTOR_FRONT_R) + ((side) ? NV20_3D_MATERIAL_FACTOR_BACK_R : \ + NV20_3D_MATERIAL_FACTOR_FRONT_R) #define MATERIAL_FACTOR_A(side) \ - ((side) ? NV20TCL_MATERIAL_FACTOR_BACK_A : \ - NV20TCL_MATERIAL_FACTOR_FRONT_A) + ((side) ? NV20_3D_MATERIAL_FACTOR_BACK_A : \ + NV20_3D_MATERIAL_FACTOR_FRONT_A) #define MATERIAL_SHININESS(side) \ - ((side) ? NV20TCL_BACK_MATERIAL_SHININESS(0) : \ - NV20TCL_FRONT_MATERIAL_SHININESS(0)) + ((side) ? NV20_3D_BACK_MATERIAL_SHININESS(0) : \ + NV20_3D_FRONT_MATERIAL_SHININESS(0)) void nv20_emit_clip_plane(struct gl_context *ctx, int emit) @@ -65,22 +65,22 @@ 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; } @@ -92,7 +92,7 @@ nv20_emit_color_material(struct gl_context *ctx, int emit) struct nouveau_grobj *kelvin = context_eng3d(ctx); unsigned mask = get_material_bitmask(ctx->Light.ColorMaterialBitmask); - BEGIN_RING(chan, kelvin, NV20TCL_COLOR_MATERIAL, 1); + BEGIN_RING(chan, kelvin, NV20_3D_COLOR_MATERIAL, 1); OUT_RING(chan, ctx->Light.ColorMaterialEnabled ? mask : 0); } @@ -101,11 +101,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); } @@ -116,11 +116,11 @@ 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); } @@ -131,9 +131,9 @@ get_fog_source(unsigned source) { 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; + return NV20_3D_FOG_COORD_DIST_ORTHOGONAL_ABS; default: assert(0); } @@ -152,15 +152,15 @@ nv20_emit_fog(struct gl_context *ctx, int emit) nv10_get_fog_coeff(ctx, k); - BEGIN_RING(chan, kelvin, NV20TCL_FOG_MODE, 4); + BEGIN_RING(chan, kelvin, NV20_3D_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_RINGb(chan, f->Enabled); OUT_RING(chan, pack_rgba_f(MESA_FORMAT_RGBA8888_REV, f->Color)); - BEGIN_RING(chan, kelvin, NV20TCL_FOG_EQUATION_CONSTANT, 3); + BEGIN_RING(chan, kelvin, NV20_3D_FOG_COEFF(0), 3); OUT_RINGp(chan, k, 3); } @@ -171,19 +171,19 @@ nv20_emit_light_model(struct gl_context *ctx, int emit) struct nouveau_grobj *kelvin = context_eng3d(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_RING(chan, kelvin, NV20_3D_SEPARATE_SPECULAR_ENABLE, 1); + OUT_RINGb(chan, m->ColorControl == GL_SEPARATE_SPECULAR_COLOR); - BEGIN_RING(chan, kelvin, NV20TCL_LIGHT_MODEL, 1); + BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_MODEL, 1); OUT_RING(chan, ((m->LocalViewer ? - NV20TCL_LIGHT_MODEL_VIEWER_LOCAL : - NV20TCL_LIGHT_MODEL_VIEWER_NONLOCAL) | + NV20_3D_LIGHT_MODEL_VIEWER_LOCAL : + NV20_3D_LIGHT_MODEL_VIEWER_NONLOCAL) | (NEED_SECONDARY_COLOR(ctx) ? - NV20TCL_LIGHT_MODEL_SEPARATE_SPECULAR : + 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_RING(chan, kelvin, NV20_3D_LIGHT_MODEL_TWO_SIDE_ENABLE, 1); + OUT_RINGb(chan, ctx->Light.Model.TwoSide); } void @@ -195,19 +195,19 @@ nv20_emit_light_source(struct gl_context *ctx, int emit) struct gl_light *l = &ctx->Light.Light[i]; if (l->_Flags & LIGHT_POSITIONAL) { - BEGIN_RING(chan, kelvin, NV20TCL_LIGHT_POSITION_X(i), 3); + BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_POSITION_X(i), 3); OUT_RINGp(chan, l->_Position, 3); - BEGIN_RING(chan, kelvin, NV20TCL_LIGHT_ATTENUATION_CONSTANT(i), 3); + BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_ATTENUATION_CONSTANT(i), 3); OUT_RINGf(chan, l->ConstantAttenuation); OUT_RINGf(chan, l->LinearAttenuation); OUT_RINGf(chan, l->QuadraticAttenuation); } else { - BEGIN_RING(chan, kelvin, NV20TCL_LIGHT_DIRECTION_X(i), 3); + BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_DIRECTION_X(i), 3); OUT_RINGp(chan, l->_VP_inf_norm, 3); - BEGIN_RING(chan, kelvin, NV20TCL_LIGHT_HALF_VECTOR_X(i), 3); + BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_HALF_VECTOR_X(i), 3); OUT_RINGp(chan, l->_h_inf_norm, 3); } @@ -216,7 +216,7 @@ nv20_emit_light_source(struct gl_context *ctx, int emit) nv10_get_spot_coeff(l, k); - BEGIN_RING(chan, kelvin, NV20TCL_LIGHT_SPOT_CUTOFF_A(i), 7); + BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_SPOT_CUTOFF(i, 0), 7); OUT_RINGp(chan, k, 7); } } @@ -340,7 +340,7 @@ nv20_emit_modelview(struct gl_context *ctx, int emit) if (ctx->Light._NeedEyeCoords || ctx->Fog.Enabled || (ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD)) { - BEGIN_RING(chan, kelvin, NV20TCL_MODELVIEW0_MATRIX(0), 16); + BEGIN_RING(chan, kelvin, NV20_3D_MODELVIEW_MATRIX(0, 0), 16); OUT_RINGm(chan, m->m); } @@ -349,7 +349,7 @@ nv20_emit_modelview(struct gl_context *ctx, int emit) int i, j; BEGIN_RING(chan, kelvin, - NV20TCL_INVERSE_MODELVIEW0_MATRIX(0), 12); + 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]); @@ -370,7 +370,7 @@ nv20_emit_projection(struct gl_context *ctx, int emit) if (nctx->fallback == HWTNL) _math_matrix_mul_matrix(&m, &m, &ctx->_ModelProjectMatrix); - BEGIN_RING(chan, kelvin, NV20TCL_PROJECTION_MATRIX(0), 16); + BEGIN_RING(chan, kelvin, NV20_3D_PROJECTION_MATRIX(0), 16); OUT_RINGm(chan, m.m); _math_matrix_dtr(&m); diff --git a/src/mesa/drivers/dri/nouveau/nv_m2mf.xml.h b/src/mesa/drivers/dri/nouveau/nv_m2mf.xml.h new file mode 100644 index 0000000000..e370a1ca06 --- /dev/null +++ b/src/mesa/drivers/dri/nouveau/nv_m2mf.xml.h @@ -0,0 +1,155 @@ +#ifndef NV_M2MF_XML +#define NV_M2MF_XML + +/* Autogenerated file, DO NOT EDIT manually! + +This file was generated by the rules-ng-ng headergen tool in this git repository: +http://0x04.net/cgit/index.cgi/rules-ng-ng +git clone git://0x04.net/rules-ng-ng + +The rules-ng-ng source files this header was generated from are: +- nv_m2mf.xml ( 2710 bytes, from 2010-11-01 00:28:46) +- copyright.xml ( 6452 bytes, from 2010-11-15 15:10:58) +- nv_object.xml ( 11547 bytes, from 2010-11-13 23:32:57) +- nvchipsets.xml ( 3074 bytes, from 2010-11-13 23:32:57) +- nv_defs.xml ( 4437 bytes, from 2010-11-01 00:28:46) + +Copyright (C) 2006-2010 by the following authors: +- Artur Huillet <arthur.huillet@free.fr> (ahuillet) +- Ben Skeggs (darktama, darktama_) +- B. R. <koala_br@users.sourceforge.net> (koala_br) +- Carlos Martin <carlosmn@users.sf.net> (carlosmn) +- Christoph Bumiller <e0425955@student.tuwien.ac.at> (calim, chrisbmr) +- Dawid Gajownik <gajownik@users.sf.net> (gajownik) +- Dmitry Baryshkov +- Dmitry Eremin-Solenikov <lumag@users.sf.net> (lumag) +- EdB <edb_@users.sf.net> (edb_) +- Erik Waling <erikwailing@users.sf.net> (erikwaling) +- Francisco Jerez <currojerez@riseup.net> (curro) +- imirkin <imirkin@users.sf.net> (imirkin) +- jb17bsome <jb17bsome@bellsouth.net> (jb17bsome) +- Jeremy Kolb <kjeremy@users.sf.net> (kjeremy) +- Laurent Carlier <lordheavym@gmail.com> (lordheavy) +- Luca Barbieri <luca@luca-barbieri.com> (lb, lb1) +- Maarten Maathuis <madman2003@gmail.com> (stillunknown) +- Marcin Kościelnicki <koriakin@0x04.net> (mwk, koriakin) +- Mark Carey <mark.carey@gmail.com> (careym) +- Matthieu Castet <matthieu.castet@parrot.com> (mat-c) +- nvidiaman <nvidiaman@users.sf.net> (nvidiaman) +- Patrice Mandin <patmandin@gmail.com> (pmandin, pmdata) +- Pekka Paalanen <pq@iki.fi> (pq, ppaalanen) +- Peter Popov <ironpeter@users.sf.net> (ironpeter) +- Richard Hughes <hughsient@users.sf.net> (hughsient) +- Rudi Cilibrasi <cilibrar@users.sf.net> (cilibrar) +- Serge Martin +- Simon Raffeiner +- Stephane Loeuillet <leroutier@users.sf.net> (leroutier) +- Stephane Marchesin <stephane.marchesin@gmail.com> (marcheu) +- sturmflut <sturmflut@users.sf.net> (sturmflut) +- Sylvain Munaut <tnt@246tNt.com> +- Victor Stinner <victor.stinner@haypocalc.com> (haypo) +- Wladmir van der Laan <laanwj@gmail.com> (miathan6) +- Younes Manton <younes.m@gmail.com> (ymanton) + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial +portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + + + +#define NV04_M2MF_DMA_NOTIFY 0x00000180 + +#define NV04_M2MF_DMA_BUFFER_IN 0x00000184 + +#define NV04_M2MF_DMA_BUFFER_OUT 0x00000188 + + +#define NV50_M2MF_LINEAR_IN 0x00000200 + +#define NV50_M2MF_TILING_MODE_IN 0x00000204 + +#define NV50_M2MF_TILING_PITCH_IN 0x00000208 + +#define NV50_M2MF_TILING_HEIGHT_IN 0x0000020c + +#define NV50_M2MF_TILING_DEPTH_IN 0x00000210 + +#define NV50_M2MF_TILING_POSITION_IN_Z 0x00000214 + +#define NV50_M2MF_TILING_POSITION_IN 0x00000218 +#define NV50_M2MF_TILING_POSITION_IN_X__MASK 0x0000ffff +#define NV50_M2MF_TILING_POSITION_IN_X__SHIFT 0 +#define NV50_M2MF_TILING_POSITION_IN_Y__MASK 0xffff0000 +#define NV50_M2MF_TILING_POSITION_IN_Y__SHIFT 16 + +#define NV50_M2MF_LINEAR_OUT 0x0000021c + +#define NV50_M2MF_TILING_MODE_OUT 0x00000220 + +#define NV50_M2MF_TILING_PITCH_OUT 0x00000224 + +#define NV50_M2MF_TILING_HEIGHT_OUT 0x00000228 + +#define NV50_M2MF_TILING_DEPTH_OUT 0x0000022c + +#define NV50_M2MF_TILING_POSITION_OUT_Z 0x00000230 + +#define NV50_M2MF_TILING_POSITION_OUT 0x00000234 +#define NV50_M2MF_TILING_POSITION_OUT_X__MASK 0x0000ffff +#define NV50_M2MF_TILING_POSITION_OUT_X__SHIFT 0 +#define NV50_M2MF_TILING_POSITION_OUT_Y__MASK 0xffff0000 +#define NV50_M2MF_TILING_POSITION_OUT_Y__SHIFT 16 + +#define NV50_M2MF_OFFSET_IN_HIGH 0x00000238 + +#define NV50_M2MF_OFFSET_OUT_HIGH 0x0000023c + +#define NV04_M2MF_OFFSET_IN 0x0000030c + +#define NV04_M2MF_OFFSET_OUT 0x00000310 + +#define NV04_M2MF_PITCH_IN 0x00000314 + +#define NV04_M2MF_PITCH_OUT 0x00000318 + +#define NV04_M2MF_LINE_LENGTH_IN 0x0000031c + +#define NV04_M2MF_LINE_COUNT 0x00000320 + +#define NV04_M2MF_FORMAT 0x00000324 +#define NV04_M2MF_FORMAT_INPUT_INC__MASK 0x000000ff +#define NV04_M2MF_FORMAT_INPUT_INC__SHIFT 0 +#define NV04_M2MF_FORMAT_INPUT_INC_1 0x00000001 +#define NV04_M2MF_FORMAT_INPUT_INC_2 0x00000002 +#define NV04_M2MF_FORMAT_INPUT_INC_4 0x00000004 +#define NV50_M2MF_FORMAT_INPUT_INC_8 0x00000008 +#define NV50_M2MF_FORMAT_INPUT_INC_16 0x00000010 +#define NV04_M2MF_FORMAT_OUTPUT_INC__MASK 0x0000ff00 +#define NV04_M2MF_FORMAT_OUTPUT_INC__SHIFT 8 +#define NV04_M2MF_FORMAT_OUTPUT_INC_1 0x00000100 +#define NV04_M2MF_FORMAT_OUTPUT_INC_2 0x00000200 +#define NV04_M2MF_FORMAT_OUTPUT_INC_4 0x00000400 +#define NV50_M2MF_FORMAT_OUTPUT_INC_8 0x00000800 +#define NV50_M2MF_FORMAT_OUTPUT_INC_16 0x00001000 + +#define NV04_M2MF_BUF_NOTIFY 0x00000328 + + +#endif /* NV_M2MF_XML */ diff --git a/src/mesa/drivers/dri/nouveau/nv_object.xml.h b/src/mesa/drivers/dri/nouveau/nv_object.xml.h new file mode 100644 index 0000000000..d5ed4bceb5 --- /dev/null +++ b/src/mesa/drivers/dri/nouveau/nv_object.xml.h @@ -0,0 +1,268 @@ +#ifndef NV_OBJECT_XML +#define NV_OBJECT_XML + +/* Autogenerated file, DO NOT EDIT manually! + +This file was generated by the rules-ng-ng headergen tool in this git repository: +http://0x04.net/cgit/index.cgi/rules-ng-ng +git clone git://0x04.net/rules-ng-ng + +The rules-ng-ng source files this header was generated from are: +- nv_object.xml ( 11547 bytes, from 2010-11-13 23:32:57) +- copyright.xml ( 6452 bytes, from 2010-11-15 15:10:58) +- nvchipsets.xml ( 3074 bytes, from 2010-11-13 23:32:57) +- nv_defs.xml ( 4437 bytes, from 2010-11-01 00:28:46) + +Copyright (C) 2006-2010 by the following authors: +- Artur Huillet <arthur.huillet@free.fr> (ahuillet) +- Ben Skeggs (darktama, darktama_) +- B. R. <koala_br@users.sourceforge.net> (koala_br) +- Carlos Martin <carlosmn@users.sf.net> (carlosmn) +- Christoph Bumiller <e0425955@student.tuwien.ac.at> (calim, chrisbmr) +- Dawid Gajownik <gajownik@users.sf.net> (gajownik) +- Dmitry Baryshkov +- Dmitry Eremin-Solenikov <lumag@users.sf.net> (lumag) +- EdB <edb_@users.sf.net> (edb_) +- Erik Waling <erikwailing@users.sf.net> (erikwaling) +- Francisco Jerez <currojerez@riseup.net> (curro) +- imirkin <imirkin@users.sf.net> (imirkin) +- jb17bsome <jb17bsome@bellsouth.net> (jb17bsome) +- Jeremy Kolb <kjeremy@users.sf.net> (kjeremy) +- Laurent Carlier <lordheavym@gmail.com> (lordheavy) +- Luca Barbieri <luca@luca-barbieri.com> (lb, lb1) +- Maarten Maathuis <madman2003@gmail.com> (stillunknown) +- Marcin Kościelnicki <koriakin@0x04.net> (mwk, koriakin) +- Mark Carey <mark.carey@gmail.com> (careym) +- Matthieu Castet <matthieu.castet@parrot.com> (mat-c) +- nvidiaman <nvidiaman@users.sf.net> (nvidiaman) +- Patrice Mandin <patmandin@gmail.com> (pmandin, pmdata) +- Pekka Paalanen <pq@iki.fi> (pq, ppaalanen) +- Peter Popov <ironpeter@users.sf.net> (ironpeter) +- Richard Hughes <hughsient@users.sf.net> (hughsient) +- Rudi Cilibrasi <cilibrar@users.sf.net> (cilibrar) +- Serge Martin +- Simon Raffeiner +- Stephane Loeuillet <leroutier@users.sf.net> (leroutier) +- Stephane Marchesin <stephane.marchesin@gmail.com> (marcheu) +- sturmflut <sturmflut@users.sf.net> (sturmflut) +- Sylvain Munaut <tnt@246tNt.com> +- Victor Stinner <victor.stinner@haypocalc.com> (haypo) +- Wladmir van der Laan <laanwj@gmail.com> (miathan6) +- Younes Manton <younes.m@gmail.com> (ymanton) + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial +portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + + +#define NV01_ROOT 0x00000001 +#define NV01_CONTEXT_DMA 0x00000002 +#define NV01_DEVICE 0x00000003 +#define NV01_TIMER 0x00000004 +#define NV01_NULL 0x00000030 +#define NV01_MEMORY_LOCAL_BANKED 0x0000003d +#define NV01_MAPPING_SYSTEM 0x0000003e +#define NV03_MEMORY_LOCAL_CURSOR 0x0000003f +#define NV01_MEMORY_LOCAL_LINEAR 0x00000040 +#define NV01_MAPPING_LOCAL 0x00000041 +#define NV03_VIDEO_LUT_CURSOR_DAC 0x00000046 +#define NV03_CHANNEL_PIO 0x0000006a +#define NV03_CHANNEL_DMA 0x0000006b +#define NV10_VIDEO_DISPLAY 0x0000007c +#define NV01_CONTEXT_BETA1 0x00000012 +#define NV04_BETA_SOLID 0x00000072 +#define NV01_CONTEXT_COLOR_KEY 0x00000017 +#define NV04_CONTEXT_COLOR_KEY 0x00000057 +#define NV01_CONTEXT_PATTERN 0x00000018 +#define NV01_CONTEXT_CLIP_RECTANGLE 0x00000019 +#define NV03_CONTEXT_ROP 0x00000043 +#define NV04_IMAGE_PATTERN 0x00000044 +#define NV01_RENDER_SOLID_LINE 0x0000001c +#define NV04_RENDER_SOLID_LINE 0x0000005c +#define NV30_RENDER_SOLID_LINE 0x0000035c +#define NV40_RENDER_SOLID_LINE 0x0000305c +#define NV01_RENDER_SOLID_TRIANGLE 0x0000001d +#define NV04_RENDER_SOLID_TRIANGLE 0x0000005d +#define NV01_RENDER_SOLID_RECTANGLE 0x0000001e +#define NV04_RENDER_SOLID_RECTANGLE 0x0000005e +#define NV01_IMAGE_BLIT 0x0000001f +#define NV04_IMAGE_BLIT 0x0000005f +#define NV11_IMAGE_BLIT 0x0000009f +#define NV01_IMAGE_FROM_CPU 0x00000021 +#define NV04_IMAGE_FROM_CPU 0x00000061 +#define NV05_IMAGE_FROM_CPU 0x00000065 +#define NV10_IMAGE_FROM_CPU 0x0000008a +#define NV30_IMAGE_FROM_CPU 0x0000038a +#define NV40_IMAGE_FROM_CPU 0x0000308a +#define NV03_STRETCHED_IMAGE_FROM_CPU 0x00000036 +#define NV04_STRETCHED_IMAGE_FROM_CPU 0x00000076 +#define NV05_STRETCHED_IMAGE_FROM_CPU 0x00000066 +#define NV30_STRETCHED_IMAGE_FROM_CPU 0x00000366 +#define NV40_STRETCHED_IMAGE_FROM_CPU 0x00003066 +#define NV03_SCALED_IMAGE_FROM_MEMORY 0x00000037 +#define NV04_SCALED_IMAGE_FROM_MEMORY 0x00000077 +#define NV05_SCALED_IMAGE_FROM_MEMORY 0x00000063 +#define NV10_SCALED_IMAGE_FROM_MEMORY 0x00000089 +#define NV30_SCALED_IMAGE_FROM_MEMORY 0x00000389 +#define NV40_SCALED_IMAGE_FROM_MEMORY 0x00003089 +#define NV50_SCALED_IMAGE_FROM_MEMORY 0x00005089 +#define NV04_DVD_SUBPICTURE 0x00000038 +#define NV10_DVD_SUBPICTURE 0x00000088 +#define NV03_GDI_RECTANGLE_TEXT 0x0000004b +#define NV04_GDI_RECTANGLE_TEXT 0x0000004a +#define NV04_SWIZZLED_SURFACE 0x00000052 +#define NV20_SWIZZLED_SURFACE 0x0000009e +#define NV30_SWIZZLED_SURFACE 0x0000039e +#define NV40_SWIZZLED_SURFACE 0x0000309e +#define NV03_CONTEXT_SURFACE_DST 0x00000058 +#define NV03_CONTEXT_SURFACE_SRC 0x00000059 +#define NV04_CONTEXT_SURFACES_2D 0x00000042 +#define NV10_CONTEXT_SURFACES_2D 0x00000062 +#define NV30_CONTEXT_SURFACES_2D 0x00000362 +#define NV40_CONTEXT_SURFACES_2D 0x00003062 +#define NV50_CONTEXT_SURFACES_2D 0x00005062 +#define NV04_INDEXED_IMAGE_FROM_CPU 0x00000060 +#define NV05_INDEXED_IMAGE_FROM_CPU 0x00000064 +#define NV30_INDEXED_IMAGE_FROM_CPU 0x00000364 +#define NV40_INDEXED_IMAGE_FROM_CPU 0x00003064 +#define NV10_TEXTURE_FROM_CPU 0x0000007b +#define NV30_TEXTURE_FROM_CPU 0x0000037b +#define NV40_TEXTURE_FROM_CPU 0x0000307b +#define NV04_M2MF 0x00000039 +#define NV50_M2MF 0x00005039 +#define NVC0_M2MF 0x00009039 +#define NV03_TEXTURED_TRIANGLE 0x00000048 +#define NV04_TEXTURED_TRIANGLE 0x00000054 +#define NV10_TEXTURED_TRIANGLE 0x00000094 +#define NV04_MULTITEX_TRIANGLE 0x00000055 +#define NV10_MULTITEX_TRIANGLE 0x00000095 +#define NV03_CONTEXT_SURFACE_COLOR 0x0000005a +#define NV03_CONTEXT_SURFACE_ZETA 0x0000005b +#define NV04_CONTEXT_SURFACES_3D 0x00000053 +#define NV10_CONTEXT_SURFACES_3D 0x00000093 +#define NV10_3D 0x00000056 +#define NV11_3D 0x00000096 +#define NV17_3D 0x00000099 +#define NV20_3D 0x00000097 +#define NV25_3D 0x00000597 +#define NV30_3D 0x00000397 +#define NV35_3D 0x00000497 +#define NV34_3D 0x00000697 +#define NV40_3D 0x00004097 +#define NV44_3D 0x00004497 +#define NV50_3D 0x00005097 +#define NV84_3D 0x00008297 +#define NVA0_3D 0x00008397 +#define NVA3_3D 0x00008597 +#define NVAF_3D 0x00008697 +#define NVC0_3D 0x00009097 +#define NV50_2D 0x0000502d +#define NVC0_2D 0x0000902d +#define NV50_COMPUTE 0x000050c0 +#define NVA3_COMPUTE 0x000085c0 +#define NVC0_COMPUTE 0x000090c0 +#define NV84_CRYPT 0x000074c1 +#define NV01_SUBCHAN__SIZE 0x00002000 +#define NV01_SUBCHAN 0x00000000 + +#define NV01_SUBCHAN_OBJECT 0x00000000 + + +#define NV84_SUBCHAN_QUERY_ADDRESS_HIGH 0x00000010 + +#define NV84_SUBCHAN_QUERY_ADDRESS_LOW 0x00000014 + +#define NV84_SUBCHAN_QUERY_COUNTER 0x00000018 + +#define NV84_SUBCHAN_QUERY_GET 0x0000001c + +#define NV84_SUBCHAN_QUERY_INTR 0x00000020 + +#define NV84_SUBCHAN_WRCACHE_FLUSH 0x00000024 + +#define NV10_SUBCHAN_REF_CNT 0x00000050 + + +#define NV11_SUBCHAN_DMA_SEMAPHORE 0x00000060 + +#define NV11_SUBCHAN_SEMAPHORE_OFFSET 0x00000064 + +#define NV11_SUBCHAN_SEMAPHORE_ACQUIRE 0x00000068 + +#define NV11_SUBCHAN_SEMAPHORE_RELEASE 0x0000006c + +#define NV40_SUBCHAN_YIELD 0x00000080 + +#define NV01_GRAPH 0x00000000 + +#define NV04_GRAPH_NOP 0x00000100 + +#define NV01_GRAPH_NOTIFY 0x00000104 +#define NV01_GRAPH_NOTIFY_WRITE 0x00000000 +#define NV01_GRAPH_NOTIFY_WRITE_AND_AWAKEN 0x00000001 + +#define NV50_GRAPH_WAIT_FOR_IDLE 0x00000110 + +#define NVA3_GRAPH_UNK0120 0x00000120 + +#define NVA3_GRAPH_UNK0124 0x00000124 + +#define NV40_GRAPH_PM_TRIGGER 0x00000140 + +#define NVC0_SUBCHAN__SIZE 0x00008000 +#define NVC0_SUBCHAN 0x00000000 + +#define NVC0_SUBCHAN_OBJECT 0x00000000 + + +#define NVC0_SUBCHAN_QUERY_ADDRESS_HIGH 0x00000010 + +#define NVC0_SUBCHAN_QUERY_ADDRESS_LOW 0x00000014 + +#define NVC0_SUBCHAN_QUERY_SEQUENCE 0x00000018 + +#define NVC0_SUBCHAN_QUERY_GET 0x0000001c + +#define NVC0_SUBCHAN_REF_CNT 0x00000050 + +#define NVC0_GRAPH 0x00000000 + +#define NVC0_GRAPH_NOP 0x00000100 + +#define NVC0_GRAPH_NOTIFY_ADDRESS_HIGH 0x00000104 + +#define NVC0_GRAPH_NOTIFY_ADDRESS_LOW 0x00000108 + +#define NVC0_GRAPH_NOTIFY 0x0000010c +#define NVC0_GRAPH_NOTIFY_WRITE 0x00000000 +#define NVC0_GRAPH_NOTIFY_WRITE_AND_AWAKEN 0x00000001 + +#define NVC0_GRAPH_SERIALIZE 0x00000110 + +#define NVC0_GRAPH_MACRO_UPLOAD_POS 0x00000114 + +#define NVC0_GRAPH_MACRO_UPLOAD_DATA 0x00000118 + +#define NVC0_GRAPH_MACRO_ID 0x0000011c + +#define NVC0_GRAPH_MACRO_POS 0x00000120 + + +#endif /* NV_OBJECT_XML */ diff --git a/src/mesa/drivers/dri/r200/r200_context.c b/src/mesa/drivers/dri/r200/r200_context.c index 723e31401d..5abfc9dac5 100644 --- a/src/mesa/drivers/dri/r200/r200_context.c +++ b/src/mesa/drivers/dri/r200/r200_context.c @@ -71,6 +71,8 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #define need_GL_NV_vertex_program #define need_GL_ARB_point_parameters #define need_GL_EXT_framebuffer_object +#define need_GL_OES_EGL_image + #include "main/remap_helper.h" #define DRIVER_DATE "20060602" @@ -137,6 +139,9 @@ static const struct dri_extension card_extensions[] = { "GL_ATI_texture_mirror_once", NULL }, { "GL_MESA_pack_invert", NULL }, { "GL_NV_blend_square", NULL }, +#if FEATURE_OES_EGL_image + { "GL_OES_EGL_image", GL_OES_EGL_image_functions }, +#endif { NULL, NULL } }; diff --git a/src/mesa/drivers/dri/r200/r200_swtcl.c b/src/mesa/drivers/dri/r200/r200_swtcl.c index 38864162ce..c56a49d5ad 100644 --- a/src/mesa/drivers/dri/r200/r200_swtcl.c +++ b/src/mesa/drivers/dri/r200/r200_swtcl.c @@ -319,10 +319,9 @@ static INLINE GLuint reduced_hw_prim( struct gl_context *ctx, GLuint prim) { switch (prim) { case GL_POINTS: - return (ctx->Point.PointSprite || - ((ctx->_TriangleCaps & (DD_POINT_SIZE | DD_POINT_ATTEN)) && - !(ctx->_TriangleCaps & (DD_POINT_SMOOTH)))) ? - R200_VF_PRIM_POINT_SPRITES : R200_VF_PRIM_POINTS; + return (((R200_CONTEXT(ctx))->radeon.radeonScreen->drmSupportsPointSprites && + !(ctx->_TriangleCaps & DD_POINT_SMOOTH)) ? + R200_VF_PRIM_POINT_SPRITES : R200_VF_PRIM_POINTS); case GL_LINES: /* fallthrough */ case GL_LINE_LOOP: diff --git a/src/mesa/drivers/dri/r200/r200_tcl.c b/src/mesa/drivers/dri/r200/r200_tcl.c index 84db7c9d4e..7aed116f0b 100644 --- a/src/mesa/drivers/dri/r200/r200_tcl.c +++ b/src/mesa/drivers/dri/r200/r200_tcl.c @@ -68,9 +68,8 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #define HAVE_ELTS 1 -#define HW_POINTS ((ctx->Point.PointSprite || \ - ((ctx->_TriangleCaps & (DD_POINT_SIZE | DD_POINT_ATTEN)) && \ - !(ctx->_TriangleCaps & (DD_POINT_SMOOTH)))) ? \ +#define HW_POINTS (((R200_CONTEXT(ctx))->radeon.radeonScreen->drmSupportsPointSprites && \ + !(ctx->_TriangleCaps & DD_POINT_SMOOTH)) ? \ R200_VF_PRIM_POINT_SPRITES : R200_VF_PRIM_POINTS) #define HW_LINES R200_VF_PRIM_LINES #define HW_LINE_LOOP 0 diff --git a/src/mesa/drivers/dri/r200/r200_tex.c b/src/mesa/drivers/dri/r200/r200_tex.c index 5207c2901a..064324731b 100644 --- a/src/mesa/drivers/dri/r200/r200_tex.c +++ b/src/mesa/drivers/dri/r200/r200_tex.c @@ -537,6 +537,10 @@ void r200InitTextureFuncs( radeonContextPtr radeon, struct dd_function_table *fu functions->MapTexture = radeonMapTexture; functions->UnmapTexture = radeonUnmapTexture; +#if FEATURE_OES_EGL_image + functions->EGLImageTargetTexture2D = radeon_image_target_texture_2d; +#endif + driInitTextureFormats(); } diff --git a/src/mesa/drivers/dri/r200/r200_texstate.c b/src/mesa/drivers/dri/r200/r200_texstate.c index 690bec640b..24fb031ecb 100644 --- a/src/mesa/drivers/dri/r200/r200_texstate.c +++ b/src/mesa/drivers/dri/r200/r200_texstate.c @@ -778,6 +778,7 @@ void r200SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint texture_format radeonTexObjPtr t; uint32_t pitch_val; uint32_t internalFormat, type, format; + gl_format texFormat; type = GL_BGRA; format = GL_UNSIGNED_BYTE; @@ -817,10 +818,6 @@ void r200SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint texture_format radeon_miptree_unreference(&t->mt); radeon_miptree_unreference(&rImage->mt); - _mesa_init_teximage_fields(radeon->glCtx, target, texImage, - rb->base.Width, rb->base.Height, 1, 0, rb->cpp); - texImage->RowStride = rb->pitch / rb->cpp; - rImage->bo = rb->bo; radeon_bo_ref(rImage->bo); t->bo = rb->bo; @@ -832,22 +829,35 @@ void r200SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint texture_format pitch_val = rb->pitch; switch (rb->cpp) { case 4: - if (texture_format == __DRI_TEXTURE_FORMAT_RGB) + if (texture_format == __DRI_TEXTURE_FORMAT_RGB) { + texFormat = MESA_FORMAT_RGB888; t->pp_txformat = tx_table_le[MESA_FORMAT_RGB888].format; - else + } + else { + texFormat = MESA_FORMAT_ARGB8888; t->pp_txformat = tx_table_le[MESA_FORMAT_ARGB8888].format; + } t->pp_txfilter |= tx_table_le[MESA_FORMAT_ARGB8888].filter; break; case 3: default: + texFormat = MESA_FORMAT_RGB888; t->pp_txformat = tx_table_le[MESA_FORMAT_RGB888].format; t->pp_txfilter |= tx_table_le[MESA_FORMAT_RGB888].filter; break; case 2: + texFormat = MESA_FORMAT_RGB565; t->pp_txformat = tx_table_le[MESA_FORMAT_RGB565].format; t->pp_txfilter |= tx_table_le[MESA_FORMAT_RGB565].filter; break; } + + _mesa_init_teximage_fields(radeon->glCtx, target, texImage, + rb->base.Width, rb->base.Height, 1, 0, + rb->cpp, texFormat); + texImage->RowStride = rb->pitch / rb->cpp; + + t->pp_txsize = ((rb->base.Width - 1) << RADEON_TEX_USIZE_SHIFT) | ((rb->base.Height - 1) << RADEON_TEX_VSIZE_SHIFT); t->pp_txformat |= R200_TXFORMAT_NON_POWER2; diff --git a/src/mesa/drivers/dri/r300/compiler/r300_fragprog_emit.c b/src/mesa/drivers/dri/r300/compiler/r300_fragprog_emit.c index 8be32ea91f..1db8678e89 100644 --- a/src/mesa/drivers/dri/r300/compiler/r300_fragprog_emit.c +++ b/src/mesa/drivers/dri/r300/compiler/r300_fragprog_emit.c @@ -76,6 +76,9 @@ static void use_temporary(struct r300_fragment_program_code *code, unsigned int static unsigned int use_source(struct r300_fragment_program_code* code, struct rc_pair_instruction_source src) { + if (!src.Used) + return 0; + if (src.File == RC_FILE_CONSTANT) { return src.Index | (1 << 5); } else if (src.File == RC_FILE_TEMPORARY) { diff --git a/src/mesa/drivers/dri/r300/compiler/r300_fragprog_swizzle.c b/src/mesa/drivers/dri/r300/compiler/r300_fragprog_swizzle.c index 2d28b06539..05d3da8a10 100644 --- a/src/mesa/drivers/dri/r300/compiler/r300_fragprog_swizzle.c +++ b/src/mesa/drivers/dri/r300/compiler/r300_fragprog_swizzle.c @@ -94,6 +94,7 @@ static const struct swizzle_data* lookup_native_swizzle(unsigned int swizzle) */ static int r300_swizzle_is_native(rc_opcode opcode, struct rc_src_register reg) { + const struct swizzle_data* sd; unsigned int relevant; int j; @@ -127,7 +128,8 @@ static int r300_swizzle_is_native(rc_opcode opcode, struct rc_src_register reg) if ((reg.Negate & relevant) && ((reg.Negate & relevant) != relevant)) return 0; - if (!lookup_native_swizzle(reg.Swizzle)) + sd = lookup_native_swizzle(reg.Swizzle); + if (!sd || (reg.File == RC_FILE_PRESUB && sd->srcp_stride == 0)) return 0; return 1; @@ -201,7 +203,7 @@ unsigned int r300FPTranslateRGBSwizzle(unsigned int src, unsigned int swizzle) { const struct swizzle_data* sd = lookup_native_swizzle(swizzle); - if (!sd) { + if (!sd || (src == RC_PAIR_PRESUB_SRC && sd->srcp_stride == 0)) { fprintf(stderr, "Not a native swizzle: %08x\n", swizzle); return 0; } diff --git a/src/mesa/drivers/dri/r300/compiler/r3xx_fragprog.c b/src/mesa/drivers/dri/r300/compiler/r3xx_fragprog.c index 2f130198d3..7b9c316794 100644 --- a/src/mesa/drivers/dri/r300/compiler/r3xx_fragprog.c +++ b/src/mesa/drivers/dri/r300/compiler/r3xx_fragprog.c @@ -137,7 +137,7 @@ void r3xx_compile_fragment_program(struct r300_fragment_program_compiler* c) /* This pass makes it easier for the scheduler to group TEX * instructions and reduces the chances of creating too * many texture indirections.*/ - {"register rename", 1, !is_r500, rc_rename_regs, NULL}, + {"register rename", 1, !is_r500 || opt, rc_rename_regs, NULL}, {"pair translate", 1, 1, rc_pair_translate, NULL}, {"pair scheduling", 1, 1, rc_pair_schedule, NULL}, {"register allocation", 1, opt, rc_pair_regalloc, NULL}, diff --git a/src/mesa/drivers/dri/r300/compiler/r500_fragprog_emit.c b/src/mesa/drivers/dri/r300/compiler/r500_fragprog_emit.c index 6f101c68eb..5da82d90f6 100644 --- a/src/mesa/drivers/dri/r300/compiler/r500_fragprog_emit.c +++ b/src/mesa/drivers/dri/r300/compiler/r500_fragprog_emit.c @@ -45,9 +45,6 @@ #include "radeon_program_pair.h" -#define MAX_BRANCH_DEPTH_FULL 32 -#define MAX_BRANCH_DEPTH_PARTIAL 4 - #define PROG_CODE \ struct r500_fragment_program_code *code = &c->code->code.r500 @@ -200,6 +197,9 @@ static void use_temporary(struct r500_fragment_program_code* code, unsigned int static unsigned int use_source(struct r500_fragment_program_code* code, struct rc_pair_instruction_source src) { + if (!src.Used) + return 0; + if (src.File == RC_FILE_CONSTANT) { return src.Index | 0x100; } else if (src.File == RC_FILE_TEMPORARY) { @@ -506,7 +506,7 @@ static void emit_flowcontrol(struct emit_state * s, struct rc_instruction * inst break; } case RC_OPCODE_IF: - if ( s->CurrentBranchDepth >= MAX_BRANCH_DEPTH_FULL) { + if ( s->CurrentBranchDepth >= R500_PFS_MAX_BRANCH_DEPTH_FULL) { rc_error(s->C, "Branch depth exceeds hardware limit"); return; } diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_code.h b/src/mesa/drivers/dri/r300/compiler/radeon_code.h index cfb6df2cd7..b69e81698a 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_code.h +++ b/src/mesa/drivers/dri/r300/compiler/radeon_code.h @@ -34,6 +34,8 @@ #define R500_PFS_MAX_INST 512 #define R500_PFS_NUM_TEMP_REGS 128 #define R500_PFS_NUM_CONST_REGS 256 +#define R500_PFS_MAX_BRANCH_DEPTH_FULL 32 +#define R500_PFS_MAX_BRANCH_DEPTH_PARTIAL 4 #define STATE_R300_WINDOW_DIMENSION (STATE_INTERNAL_DRIVER+0) diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_compiler_util.c b/src/mesa/drivers/dri/r300/compiler/radeon_compiler_util.c index 97f4c75849..2b8d284ce9 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_compiler_util.c +++ b/src/mesa/drivers/dri/r300/compiler/radeon_compiler_util.c @@ -31,6 +31,8 @@ #include "radeon_compiler_util.h" +#include "radeon_compiler.h" +#include "radeon_dataflow.h" /** */ unsigned int rc_swizzle_to_writemask(unsigned int swz) @@ -59,3 +61,123 @@ unsigned int rc_src_reads_dst_mask( } return dst_mask & rc_swizzle_to_writemask(src_swz); } + +unsigned int rc_source_type_swz(unsigned int swizzle, unsigned int channels) +{ + unsigned int chan; + unsigned int swz = RC_SWIZZLE_UNUSED; + unsigned int ret = RC_SOURCE_NONE; + + for(chan = 0; chan < channels; chan++) { + swz = GET_SWZ(swizzle, chan); + if (swz == RC_SWIZZLE_W) { + ret |= RC_SOURCE_ALPHA; + } else if (swz == RC_SWIZZLE_X || swz == RC_SWIZZLE_Y + || swz == RC_SWIZZLE_Z) { + ret |= RC_SOURCE_RGB; + } + } + return ret; +} + +unsigned int rc_source_type_mask(unsigned int mask) +{ + unsigned int ret = RC_SOURCE_NONE; + + if (mask & RC_MASK_XYZ) + ret |= RC_SOURCE_RGB; + + if (mask & RC_MASK_W) + ret |= RC_SOURCE_ALPHA; + + return ret; +} + +struct can_use_presub_data { + struct rc_src_register RemoveSrcs[3]; + unsigned int RGBCount; + unsigned int AlphaCount; +}; + +static void can_use_presub_read_cb( + void * userdata, + struct rc_instruction * inst, + rc_register_file file, + unsigned int index, + unsigned int mask) +{ + struct can_use_presub_data * d = userdata; + unsigned int src_type = rc_source_type_mask(mask); + unsigned int i; + + if (file == RC_FILE_NONE) + return; + + for(i = 0; i < 3; i++) { + if (d->RemoveSrcs[i].File == file + && d->RemoveSrcs[i].Index == index) { + src_type &= + ~rc_source_type_swz(d->RemoveSrcs[i].Swizzle, 4); + } + } + + if (src_type & RC_SOURCE_RGB) + d->RGBCount++; + + if (src_type & RC_SOURCE_ALPHA) + d->AlphaCount++; +} + +unsigned int rc_inst_can_use_presub( + struct rc_instruction * inst, + rc_presubtract_op presub_op, + unsigned int presub_writemask, + struct rc_src_register replace_reg, + struct rc_src_register presub_src0, + struct rc_src_register presub_src1) +{ + struct can_use_presub_data d; + unsigned int num_presub_srcs; + unsigned int presub_src_type = rc_source_type_mask(presub_writemask); + const struct rc_opcode_info * info = + rc_get_opcode_info(inst->U.I.Opcode); + + if (presub_op == RC_PRESUB_NONE) { + return 1; + } + + if (info->HasTexture) { + return 0; + } + + /* We can't use more than one presubtract value in an + * instruction, unless the two prsubtract operations + * are the same and read from the same registers. + * XXX For now we will limit instructions to only one presubtract + * value.*/ + if (inst->U.I.PreSub.Opcode != RC_PRESUB_NONE) { + return 0; + } + + memset(&d, 0, sizeof(d)); + d.RemoveSrcs[0] = replace_reg; + d.RemoveSrcs[1] = presub_src0; + d.RemoveSrcs[2] = presub_src1; + + rc_for_all_reads_mask(inst, can_use_presub_read_cb, &d); + + num_presub_srcs = rc_presubtract_src_reg_count(presub_op); + + if ((presub_src_type & RC_SOURCE_RGB) + && d.RGBCount + num_presub_srcs > 3) { + return 0; + } + + if ((presub_src_type & RC_SOURCE_ALPHA) + && d.AlphaCount + num_presub_srcs > 3) { + return 0; + } + + return 1; +} + diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_compiler_util.h b/src/mesa/drivers/dri/r300/compiler/radeon_compiler_util.h index 1a14e7cb0e..e50dfbd4fb 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_compiler_util.h +++ b/src/mesa/drivers/dri/r300/compiler/radeon_compiler_util.h @@ -3,6 +3,9 @@ #ifndef RADEON_PROGRAM_UTIL_H #define RADEON_PROGRAM_UTIL_H +struct rc_instruction; +struct rc_src_register; + unsigned int rc_swizzle_to_writemask(unsigned int swz); unsigned int rc_src_reads_dst_mask( @@ -13,4 +16,16 @@ unsigned int rc_src_reads_dst_mask( unsigned int dst_idx, unsigned int dst_mask); +unsigned int rc_source_type_swz(unsigned int swizzle, unsigned int channels); + +unsigned int rc_source_type_mask(unsigned int mask); + +unsigned int rc_inst_can_use_presub( + struct rc_instruction * inst, + rc_presubtract_op presub_op, + unsigned int presub_writemask, + struct rc_src_register replace_reg, + struct rc_src_register presub_src0, + struct rc_src_register presub_src1); + #endif /* RADEON_PROGRAM_UTIL_H */ diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_dataflow.c b/src/mesa/drivers/dri/r300/compiler/radeon_dataflow.c index 5927498818..9df07edf2b 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_dataflow.c +++ b/src/mesa/drivers/dri/r300/compiler/radeon_dataflow.c @@ -139,7 +139,46 @@ static void pair_sub_for_all_args( const struct rc_opcode_info * info = rc_get_opcode_info(sub->Opcode); for(i = 0; i < info->NumSrcRegs; i++) { - cb(userdata, fullinst, &sub->Arg[i]); + unsigned int src_type; + unsigned int channels = 0; + if (&fullinst->U.P.RGB == sub) + channels = 3; + else if (&fullinst->U.P.Alpha == sub) + channels = 1; + + assert(channels > 0); + src_type = rc_source_type_swz(sub->Arg[i].Swizzle, channels); + + if (src_type == RC_SOURCE_NONE) + continue; + + if (sub->Arg[i].Source == RC_PAIR_PRESUB_SRC) { + unsigned int presub_type; + unsigned int presub_src_count; + struct rc_pair_instruction_source * src_array; + unsigned int j; + if (src_type & RC_SOURCE_RGB) { + presub_type = fullinst-> + U.P.RGB.Src[RC_PAIR_PRESUB_SRC].Index; + src_array = fullinst->U.P.RGB.Src; + } else { + presub_type = fullinst-> + U.P.Alpha.Src[RC_PAIR_PRESUB_SRC].Index; + src_array = fullinst->U.P.Alpha.Src; + } + presub_src_count + = rc_presubtract_src_reg_count(presub_type); + for(j = 0; j < presub_src_count; j++) { + cb(userdata, fullinst, &sub->Arg[i], + &src_array[j]); + } + } else { + struct rc_pair_instruction_source * src = + rc_pair_get_src(&fullinst->U.P, &sub->Arg[i]); + if (src) { + cb(userdata, fullinst, &sub->Arg[i], src); + } + } } } @@ -430,12 +469,29 @@ static rc_opcode get_flow_control_inst(struct rc_instruction * inst) } +struct branch_write_mask { + unsigned int IfWriteMask:4; + unsigned int ElseWriteMask:4; + unsigned int HasElse:1; +}; + +union get_readers_read_cb { + rc_read_src_fn I; + rc_pair_read_arg_fn P; +}; + struct get_readers_callback_data { struct radeon_compiler * C; struct rc_reader_data * ReaderData; - rc_read_src_fn ReadCB; + rc_read_src_fn ReadNormalCB; + rc_pair_read_arg_fn ReadPairCB; rc_read_write_mask_fn WriteCB; + rc_register_file DstFile; + unsigned int DstIndex; + unsigned int DstMask; unsigned int AliveWriteMask; + /* For convenience, this is indexed starting at 1 */ + struct branch_write_mask BranchMasks[R500_PFS_MAX_BRANCH_DEPTH_FULL + 1]; }; static void add_reader( @@ -443,7 +499,7 @@ static void add_reader( struct rc_reader_data * data, struct rc_instruction * inst, unsigned int mask, - struct rc_src_register * src) + void * arg_or_src) { struct rc_reader * new; memory_pool_array_reserve(pool, struct rc_reader, data->Readers, @@ -451,7 +507,74 @@ static void add_reader( new = &data->Readers[data->ReaderCount++]; new->Inst = inst; new->WriteMask = mask; - new->Src = src; + if (inst->Type == RC_INSTRUCTION_NORMAL) { + new->U.Src = arg_or_src; + } else { + new->U.Arg = arg_or_src; + } +} + +static unsigned int get_readers_read_callback( + struct get_readers_callback_data * cb_data, + unsigned int has_rel_addr, + rc_register_file file, + unsigned int index, + unsigned int swizzle) +{ + unsigned int shared_mask, read_mask; + + if (has_rel_addr) { + cb_data->ReaderData->Abort = 1; + return RC_MASK_NONE; + } + + shared_mask = rc_src_reads_dst_mask(file, index, swizzle, + cb_data->DstFile, cb_data->DstIndex, cb_data->AliveWriteMask); + + if (shared_mask == RC_MASK_NONE) + return shared_mask; + + /* If we make it this far, it means that this source reads from the + * same register written to by d->ReaderData->Writer. */ + + read_mask = rc_swizzle_to_writemask(swizzle); + if (cb_data->ReaderData->AbortOnRead & read_mask) { + cb_data->ReaderData->Abort = 1; + return shared_mask; + } + + /* XXX The behavior in this case should be configurable. */ + if ((read_mask & cb_data->AliveWriteMask) != read_mask) { + cb_data->ReaderData->Abort = 1; + return shared_mask; + } + + return shared_mask; +} + +static void get_readers_pair_read_callback( + void * userdata, + struct rc_instruction * inst, + struct rc_pair_instruction_arg * arg, + struct rc_pair_instruction_source * src) +{ + unsigned int shared_mask; + struct get_readers_callback_data * d = userdata; + + shared_mask = get_readers_read_callback(d, + 0 /*Pair Instructions don't use RelAddr*/, + src->File, src->Index, arg->Swizzle); + + if (shared_mask == RC_MASK_NONE) + return; + + if (d->ReadPairCB) + d->ReadPairCB(d->ReaderData, inst, arg, src); + + if (d->ReaderData->Abort) + return; + + add_reader(&d->C->Pool, d->ReaderData, inst, shared_mask, arg); } /** @@ -464,36 +587,18 @@ static void get_readers_normal_read_callback( struct rc_src_register * src) { struct get_readers_callback_data * d = userdata; - unsigned int read_mask; - - if (src->RelAddr) - d->ReaderData->Abort = 1; + unsigned int shared_mask; - unsigned int shared_mask = rc_src_reads_dst_mask(src->File, src->Index, - src->Swizzle, - d->ReaderData->Writer->U.I.DstReg.File, - d->ReaderData->Writer->U.I.DstReg.Index, - d->AliveWriteMask); + shared_mask = get_readers_read_callback(d, + src->RelAddr, src->File, src->Index, src->Swizzle); if (shared_mask == RC_MASK_NONE) return; + /* The callback function could potentially clear d->ReaderData->Abort, + * so we need to call it before we return. */ + if (d->ReadNormalCB) + d->ReadNormalCB(d->ReaderData, inst, src); - /* If we make it this far, it means that this source reads from the - * same register written to by d->ReaderData->Writer. */ - - if (d->ReaderData->AbortOnRead) { - d->ReaderData->Abort = 1; - return; - } - - read_mask = rc_swizzle_to_writemask(src->Swizzle); - /* XXX The behavior in this case should be configurable. */ - if ((read_mask & d->AliveWriteMask) != read_mask) { - d->ReaderData->Abort = 1; - return; - } - - d->ReadCB(d->ReaderData, inst, src); if (d->ReaderData->Abort) return; @@ -514,29 +619,132 @@ static void get_readers_write_callback( { struct get_readers_callback_data * d = userdata; - if (index == d->ReaderData->Writer->U.I.DstReg.Index - && file == d->ReaderData->Writer->U.I.DstReg.File) { - unsigned int shared_mask = mask - & d->ReaderData->Writer->U.I.DstReg.WriteMask; - if (d->ReaderData->InElse) { - if (shared_mask & d->AliveWriteMask) { - /* We set AbortOnRead here because the - * destination register of d->ReaderData->Writer - * is written to in both the IF and the - * ELSE block of this IF/ELSE statement. - * This means that readers of this - * destination register that follow this IF/ELSE - * statement use the value of different - * instructions depending on the control flow - * decisions made by the program. */ - d->ReaderData->AbortOnRead = 1; + if (index == d->DstIndex && file == d->DstFile) { + unsigned int shared_mask = mask & d->DstMask; + d->ReaderData->AbortOnRead &= ~shared_mask; + d->AliveWriteMask &= ~shared_mask; + } + + if(d->WriteCB) + d->WriteCB(d->ReaderData, inst, file, index, mask); +} + +static void get_readers_for_single_write( + void * userdata, + struct rc_instruction * writer, + rc_register_file dst_file, + unsigned int dst_index, + unsigned int dst_mask) +{ + struct rc_instruction * tmp; + unsigned int branch_depth = 0; + struct get_readers_callback_data * d = userdata; + + d->ReaderData->Writer = writer; + d->ReaderData->AbortOnRead = 0; + d->ReaderData->InElse = 0; + d->DstFile = dst_file; + d->DstIndex = dst_index; + d->DstMask = dst_mask; + d->AliveWriteMask = dst_mask; + memset(d->BranchMasks, 0, sizeof(d->BranchMasks)); + + if (!dst_mask) + return; + + for(tmp = writer->Next; tmp != &d->C->Program.Instructions; + tmp = tmp->Next){ + rc_opcode opcode = get_flow_control_inst(tmp); + switch(opcode) { + case RC_OPCODE_BGNLOOP: + /* XXX We can do better when we see a BGNLOOP if we + * add a flag called AbortOnWrite to struct + * rc_reader_data and leave it set until the next + * ENDLOOP. */ + case RC_OPCODE_ENDLOOP: + /* XXX We can do better when we see an ENDLOOP by + * searching backwards from writer and looking for + * readers of writer's destination index. If we find a + * reader before we get to the BGNLOOP, we must abort + * unless there is another writer between that reader + * and the BGNLOOP. */ + case RC_OPCODE_BRK: + case RC_OPCODE_CONT: + d->ReaderData->Abort = 1; + return; + case RC_OPCODE_IF: + branch_depth++; + if (branch_depth > R500_PFS_MAX_BRANCH_DEPTH_FULL) { + d->ReaderData->Abort = 1; + return; + } + d->BranchMasks[branch_depth].IfWriteMask = + d->AliveWriteMask; + break; + case RC_OPCODE_ELSE: + if (branch_depth == 0) { + d->ReaderData->InElse = 1; + } else { + unsigned int temp_mask = d->AliveWriteMask; + d->AliveWriteMask = + d->BranchMasks[branch_depth].IfWriteMask; + d->BranchMasks[branch_depth].ElseWriteMask = + temp_mask; + d->BranchMasks[branch_depth].HasElse = 1; + } + break; + case RC_OPCODE_ENDIF: + if (branch_depth == 0) { + d->ReaderData->AbortOnRead = d->AliveWriteMask; + d->ReaderData->InElse = 0; + } + else { + struct branch_write_mask * masks = + &d->BranchMasks[branch_depth]; + + if (masks->HasElse) { + d->ReaderData->AbortOnRead |= + masks->IfWriteMask + & ~masks->ElseWriteMask; + d->AliveWriteMask = masks->IfWriteMask + ^ ((masks->IfWriteMask ^ + masks->ElseWriteMask) + & (masks->IfWriteMask + ^ d->AliveWriteMask)); + } else { + d->ReaderData->AbortOnRead |= + masks->IfWriteMask + & ~d->AliveWriteMask; + d->AliveWriteMask = masks->IfWriteMask; + + } + memset(masks, 0, + sizeof(struct branch_write_mask)); + branch_depth--; } + break; + default: + break; + } + + if (d->ReaderData->InElse) + continue; + + if (tmp->Type == RC_INSTRUCTION_NORMAL) { + rc_for_all_reads_src(tmp, + get_readers_normal_read_callback, d); } else { - d->AliveWriteMask &= ~shared_mask; + rc_pair_for_all_reads_arg(tmp, + get_readers_pair_read_callback, d); } - } + rc_for_all_writes_mask(tmp, get_readers_write_callback, d); + + if (d->ReaderData->Abort) + return; - d->WriteCB(d->ReaderData, inst, file, index, mask); + if (branch_depth == 0 && !d->AliveWriteMask) + return; + } } /** @@ -577,80 +785,26 @@ static void get_readers_write_callback( * @param write_cb This function will be called for every instruction after * writer. */ -void rc_get_readers_normal( +void rc_get_readers( struct radeon_compiler * c, struct rc_instruction * writer, struct rc_reader_data * data, - rc_read_src_fn read_cb, + rc_read_src_fn read_normal_cb, + rc_pair_read_arg_fn read_pair_cb, rc_read_write_mask_fn write_cb) { - struct rc_instruction * tmp; struct get_readers_callback_data d; - unsigned int branch_depth = 0; - data->Writer = writer; data->Abort = 0; - data->AbortOnRead = 0; - data->InElse = 0; data->ReaderCount = 0; data->ReadersReserved = 0; data->Readers = NULL; d.C = c; - d.AliveWriteMask = writer->U.I.DstReg.WriteMask; d.ReaderData = data; - d.ReadCB = read_cb; + d.ReadNormalCB = read_normal_cb; + d.ReadPairCB = read_pair_cb; d.WriteCB = write_cb; - if (!writer->U.I.DstReg.WriteMask) - return; - - for(tmp = writer->Next; tmp != &c->Program.Instructions; - tmp = tmp->Next){ - rc_opcode opcode = get_flow_control_inst(tmp); - switch(opcode) { - case RC_OPCODE_BGNLOOP: - /* XXX We can do better when we see a BGNLOOP if we - * add a flag called AbortOnWrite to struct - * rc_reader_data and leave it set until the next - * ENDLOOP. */ - case RC_OPCODE_ENDLOOP: - /* XXX We can do better when we see an ENDLOOP by - * searching backwards from writer and looking for - * readers of writer's destination index. If we find a - * reader before we get to the BGNLOOP, we must abort - * unless there is another writer between that reader - * and the BGNLOOP. */ - data->Abort = 1; - return; - case RC_OPCODE_IF: - branch_depth++; - break; - case RC_OPCODE_ELSE: - if (branch_depth == 0) - data->InElse = 1; - break; - case RC_OPCODE_ENDIF: - if (branch_depth == 0) { - data->AbortOnRead = 1; - data->InElse = 0; - } - else { - branch_depth--; - } - break; - default: - break; - } - - if (!data->InElse) - rc_for_all_reads_src(tmp, get_readers_normal_read_callback, &d); - rc_for_all_writes_mask(tmp, get_readers_write_callback, &d); - - if (data->Abort) - return; - - if (!d.AliveWriteMask) - return; - } + rc_for_all_writes_mask(writer, get_readers_for_single_write, &d); } diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_dataflow.h b/src/mesa/drivers/dri/r300/compiler/radeon_dataflow.h index 7de6b98f76..ef971c5b23 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_dataflow.h +++ b/src/mesa/drivers/dri/r300/compiler/radeon_dataflow.h @@ -36,6 +36,7 @@ struct rc_instruction; struct rc_swizzle_caps; struct rc_src_register; struct rc_pair_instruction_arg; +struct rc_pair_instruction_source; struct rc_compiler; @@ -59,7 +60,8 @@ void rc_for_all_reads_src(struct rc_instruction * inst, rc_read_src_fn cb, void * userdata); typedef void (*rc_pair_read_arg_fn)(void * userdata, - struct rc_instruction * inst, struct rc_pair_instruction_arg * arg); + struct rc_instruction * inst, struct rc_pair_instruction_arg * arg, + struct rc_pair_instruction_source * src); void rc_pair_for_all_reads_arg(struct rc_instruction * inst, rc_pair_read_arg_fn cb, void * userdata); @@ -71,7 +73,10 @@ void rc_remap_registers(struct rc_instruction * inst, rc_remap_register_fn cb, v struct rc_reader { struct rc_instruction * Inst; unsigned int WriteMask; - struct rc_src_register * Src; + union { + struct rc_src_register * Src; + struct rc_pair_instruction_arg * Arg; + } U; }; struct rc_reader_data { @@ -87,14 +92,13 @@ struct rc_reader_data { void * CbData; }; -void rc_get_readers_normal( +void rc_get_readers( struct radeon_compiler * c, - struct rc_instruction * inst, + struct rc_instruction * writer, struct rc_reader_data * data, - /*XXX: These should be their own function types. */ - rc_read_src_fn read_cb, + rc_read_src_fn read_normal_cb, + rc_pair_read_arg_fn read_pair_cb, rc_read_write_mask_fn write_cb); - /** * Compiler passes based on dataflow analysis. */ diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_optimize.c b/src/mesa/drivers/dri/r300/compiler/radeon_optimize.c index 4d9120ffd0..27b10ffbd6 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_optimize.c +++ b/src/mesa/drivers/dri/r300/compiler/radeon_optimize.c @@ -32,15 +32,14 @@ #include "radeon_compiler_util.h" #include "radeon_swizzle.h" -struct peephole_state { - struct rc_instruction * Inst; - /** Stores a bitmask of the components that are still "alive" (i.e. - * they have not been written to since Inst was executed.) - */ - unsigned int WriteMask; +struct src_clobbered_reads_cb_data { + rc_register_file File; + unsigned int Index; + unsigned int Mask; + struct rc_reader_data * ReaderData; }; -typedef void (*rc_presub_replace_fn)(struct peephole_state *, +typedef void (*rc_presub_replace_fn)(struct rc_instruction *, struct rc_instruction *, unsigned int); @@ -67,38 +66,18 @@ static struct rc_src_register chain_srcregs(struct rc_src_register outer, struct return combine; } -struct copy_propagate_state { - struct radeon_compiler * C; - struct rc_instruction * Mov; - unsigned int Conflict:1; - - /** Whether Mov's source has been clobbered */ - unsigned int SourceClobbered:1; - - /** Which components of Mov's destination register are still from that Mov? */ - unsigned int MovMask:4; - - /** Which components of Mov's destination register are clearly *not* from that Mov */ - unsigned int DefinedMask:4; - - /** Which components of Mov's source register are sourced */ - unsigned int SourcedMask:4; - - /** Branch depth beyond Mov; negative value indicates we left the Mov's block */ - int BranchDepth; -}; - static void copy_propagate_scan_read(void * data, struct rc_instruction * inst, struct rc_src_register * src) { rc_register_file file = src->File; struct rc_reader_data * reader_data = data; - const struct rc_opcode_info * info = rc_get_opcode_info(inst->U.I.Opcode); - /* It is possible to do copy propigation in this situation, - * just not right now, see peephole_add_presub_inv() */ - if (reader_data->Writer->U.I.PreSub.Opcode != RC_PRESUB_NONE && - (info->NumSrcRegs > 2 || info->HasTexture)) { + if(!rc_inst_can_use_presub(inst, + reader_data->Writer->U.I.PreSub.Opcode, + rc_swizzle_to_writemask(src->Swizzle), + *src, + reader_data->Writer->U.I.PreSub.SrcReg[0], + reader_data->Writer->U.I.PreSub.SrcReg[1])) { reader_data->Abort = 1; return; } @@ -123,23 +102,44 @@ static void copy_propagate_scan_read(void * data, struct rc_instruction * inst, } } -static void copy_propagate_scan_write(void * data, struct rc_instruction * inst, - rc_register_file file, unsigned int index, unsigned int mask) +static void src_clobbered_reads_cb( + void * data, + struct rc_instruction * inst, + struct rc_src_register * src) { - struct rc_reader_data * reader_data = data; - struct copy_propagate_state * s = reader_data->CbData; + struct src_clobbered_reads_cb_data * sc_data = data; + + if (src->File == sc_data->File + && src->Index == sc_data->Index + && (rc_swizzle_to_writemask(src->Swizzle) & sc_data->Mask)) { - if (file == reader_data->Writer->U.I.SrcReg[0].File && index == reader_data->Writer->U.I.SrcReg[0].Index) { - if (mask & s->SourcedMask) - reader_data->AbortOnRead = 1; - } else if (s->Mov->U.I.SrcReg[0].RelAddr && file == RC_FILE_ADDRESS) { - reader_data->AbortOnRead = 1; + sc_data->ReaderData->AbortOnRead = RC_MASK_XYZW; } + + if (src->RelAddr && sc_data->File == RC_FILE_ADDRESS) { + sc_data->ReaderData->AbortOnRead = RC_MASK_XYZW; + } +} + +static void is_src_clobbered_scan_write( + void * data, + struct rc_instruction * inst, + rc_register_file file, + unsigned int index, + unsigned int mask) +{ + struct src_clobbered_reads_cb_data sc_data; + struct rc_reader_data * reader_data = data; + sc_data.File = file; + sc_data.Index = index; + sc_data.Mask = mask; + sc_data.ReaderData = reader_data; + rc_for_all_reads_src(reader_data->Writer, + src_clobbered_reads_cb, &sc_data); } static void copy_propagate(struct radeon_compiler * c, struct rc_instruction * inst_mov) { - struct copy_propagate_state s; struct rc_reader_data reader_data; unsigned int i; @@ -149,22 +149,10 @@ static void copy_propagate(struct radeon_compiler * c, struct rc_instruction * i inst_mov->U.I.SaturateMode) return; - memset(&s, 0, sizeof(s)); - s.C = c; - s.Mov = inst_mov; - s.MovMask = inst_mov->U.I.DstReg.WriteMask; - s.DefinedMask = RC_MASK_XYZW & ~s.MovMask; - - reader_data.CbData = &s; - - for(unsigned int chan = 0; chan < 4; ++chan) { - unsigned int swz = GET_SWZ(inst_mov->U.I.SrcReg[0].Swizzle, chan); - s.SourcedMask |= (1 << swz) & RC_MASK_XYZW; - } - /* Get a list of all the readers of this MOV instruction. */ - rc_get_readers_normal(c, inst_mov, &reader_data, - copy_propagate_scan_read, copy_propagate_scan_write); + rc_get_readers(c, inst_mov, &reader_data, + copy_propagate_scan_read, NULL, + is_src_clobbered_scan_write); if (reader_data.Abort || reader_data.ReaderCount == 0) return; @@ -172,10 +160,10 @@ static void copy_propagate(struct radeon_compiler * c, struct rc_instruction * i /* Propagate the MOV instruction. */ for (i = 0; i < reader_data.ReaderCount; i++) { struct rc_instruction * inst = reader_data.Readers[i].Inst; - *reader_data.Readers[i].Src = chain_srcregs(*reader_data.Readers[i].Src, s.Mov->U.I.SrcReg[0]); + *reader_data.Readers[i].U.Src = chain_srcregs(*reader_data.Readers[i].U.Src, inst_mov->U.I.SrcReg[0]); - if (s.Mov->U.I.SrcReg[0].File == RC_FILE_PRESUB) - inst->U.I.PreSub = s.Mov->U.I.PreSub; + if (inst_mov->U.I.SrcReg[0].File == RC_FILE_PRESUB) + inst->U.I.PreSub = inst_mov->U.I.PreSub; } /* Finally, remove the original MOV instruction */ @@ -222,8 +210,8 @@ static int is_src_uniform_constant(struct rc_src_register src, static void constant_folding_mad(struct rc_instruction * inst) { - rc_swizzle swz; - unsigned int negate; + rc_swizzle swz = 0; + unsigned int negate= 0; if (is_src_uniform_constant(inst->U.I.SrcReg[2], &swz, &negate)) { if (swz == RC_SWIZZLE_ZERO) { @@ -263,8 +251,8 @@ static void constant_folding_mad(struct rc_instruction * inst) static void constant_folding_mul(struct rc_instruction * inst) { - rc_swizzle swz; - unsigned int negate; + rc_swizzle swz = 0; + unsigned int negate = 0; if (is_src_uniform_constant(inst->U.I.SrcReg[0], &swz, &negate)) { if (swz == RC_SWIZZLE_ONE) { @@ -296,8 +284,8 @@ static void constant_folding_mul(struct rc_instruction * inst) static void constant_folding_add(struct rc_instruction * inst) { - rc_swizzle swz; - unsigned int negate; + rc_swizzle swz = 0; + unsigned int negate = 0; if (is_src_uniform_constant(inst->U.I.SrcReg[0], &swz, &negate)) { if (swz == RC_SWIZZLE_ZERO) { @@ -431,132 +419,88 @@ static int src_has_const_swz(struct rc_src_register src) { return 0; } -static void peephole_scan_write(void * data, struct rc_instruction * inst, - rc_register_file file, unsigned int index, unsigned int mask) +static void presub_scan_read( + void * data, + struct rc_instruction * inst, + struct rc_src_register * src) { - struct peephole_state * s = data; - if(s->Inst->U.I.DstReg.File == file - && s->Inst->U.I.DstReg.Index == index) { - unsigned int common_mask = s->WriteMask & mask; - s->WriteMask &= ~common_mask; + struct rc_reader_data * reader_data = data; + rc_presubtract_op * presub_opcode = reader_data->CbData; + + if (!rc_inst_can_use_presub(inst, *presub_opcode, + reader_data->Writer->U.I.DstReg.WriteMask, + *src, + reader_data->Writer->U.I.SrcReg[0], + reader_data->Writer->U.I.SrcReg[1])) { + reader_data->Abort = 1; + return; } } static int presub_helper( struct radeon_compiler * c, - struct peephole_state * s, + struct rc_instruction * inst_add, rc_presubtract_op presub_opcode, rc_presub_replace_fn presub_replace) { - struct rc_instruction * inst; - unsigned int can_remove = 0; - unsigned int cant_sub = 0; - - for(inst = s->Inst->Next; inst != &c->Program.Instructions; - inst = inst->Next) { - unsigned int i; - unsigned char can_use_presub = 1; - const struct rc_opcode_info * info = - rc_get_opcode_info(inst->U.I.Opcode); - /* XXX: There are some situations where instructions - * with more than 2 src registers can use the - * presubtract select, but to keep things simple we - * will disable presubtract on these instructions for - * now. */ - if (info->NumSrcRegs > 2 || info->HasTexture) { - can_use_presub = 0; - } + struct rc_reader_data reader_data; + unsigned int i; + rc_presubtract_op cb_op = presub_opcode; - /* We can't use more than one presubtract value in an - * instruction, unless the two prsubtract operations - * are the same and read from the same registers. */ - if (inst->U.I.PreSub.Opcode != RC_PRESUB_NONE) { - if (inst->U.I.PreSub.Opcode != presub_opcode - || inst->U.I.PreSub.SrcReg[0].File != - s->Inst->U.I.SrcReg[1].File - || inst->U.I.PreSub.SrcReg[0].Index != - s->Inst->U.I.SrcReg[1].Index) { - can_use_presub = 0; - } - } + reader_data.CbData = &cb_op; + rc_get_readers(c, inst_add, &reader_data, presub_scan_read, NULL, + is_src_clobbered_scan_write); - /* Even if the instruction can't use a presubtract operation - * we still need to check if the instruction reads from - * s->Inst->U.I.DstReg, because if it does we must not - * remove s->Inst. */ - for(i = 0; i < info->NumSrcRegs; i++) { - unsigned int mask = src_reads_dst_mask( - inst->U.I.SrcReg[i], s->Inst->U.I.DstReg); - /* XXX We could be more aggressive here using - * presubtract. It is okay if SrcReg[i] only reads - * from some of the mask components. */ - if(s->Inst->U.I.DstReg.WriteMask != mask) { - if (s->Inst->U.I.DstReg.WriteMask & mask) { - can_remove = 0; - break; - } else { - continue; - } - } - if (cant_sub || !can_use_presub) { - can_remove = 0; - break; - } - presub_replace(s, inst, i); - can_remove = 1; - } - if(!can_remove) - break; - rc_for_all_writes_mask(inst, peephole_scan_write, s); - /* If all components of inst_add's destination register have - * been written to by subsequent instructions, the original - * value of the destination register is no longer valid and - * we can't keep doing substitutions. */ - if (!s->WriteMask){ - break; - } - /* Make this instruction doesn't write to the presubtract source. */ - if (inst->U.I.DstReg.WriteMask & - src_reads_dst_mask(s->Inst->U.I.SrcReg[1], - inst->U.I.DstReg) - || src_reads_dst_mask(s->Inst->U.I.SrcReg[0], - inst->U.I.DstReg) - || info->IsFlowControl) { - cant_sub = 1; + if (reader_data.Abort || reader_data.ReaderCount == 0) + return 0; + + for(i = 0; i < reader_data.ReaderCount; i++) { + unsigned int src_index; + struct rc_reader reader = reader_data.Readers[i]; + const struct rc_opcode_info * info = + rc_get_opcode_info(reader.Inst->U.I.Opcode); + + for (src_index = 0; src_index < info->NumSrcRegs; src_index++) { + if (&reader.Inst->U.I.SrcReg[src_index] == reader.U.Src) + presub_replace(inst_add, reader.Inst, src_index); } } - return can_remove; + return 1; } -/* This function assumes that s->Inst->U.I.SrcReg[0] and - * s->Inst->U.I.SrcReg[1] aren't both negative. */ -static void presub_replace_add(struct peephole_state *s, - struct rc_instruction * inst, - unsigned int src_index) +/* This function assumes that inst_add->U.I.SrcReg[0] and + * inst_add->U.I.SrcReg[1] aren't both negative. */ +static void presub_replace_add( + struct rc_instruction * inst_add, + struct rc_instruction * inst_reader, + unsigned int src_index) { rc_presubtract_op presub_opcode; - if (s->Inst->U.I.SrcReg[1].Negate || s->Inst->U.I.SrcReg[0].Negate) + if (inst_add->U.I.SrcReg[1].Negate || inst_add->U.I.SrcReg[0].Negate) presub_opcode = RC_PRESUB_SUB; else presub_opcode = RC_PRESUB_ADD; - if (s->Inst->U.I.SrcReg[1].Negate) { - inst->U.I.PreSub.SrcReg[0] = s->Inst->U.I.SrcReg[1]; - inst->U.I.PreSub.SrcReg[1] = s->Inst->U.I.SrcReg[0]; + if (inst_add->U.I.SrcReg[1].Negate) { + inst_reader->U.I.PreSub.SrcReg[0] = inst_add->U.I.SrcReg[1]; + inst_reader->U.I.PreSub.SrcReg[1] = inst_add->U.I.SrcReg[0]; } else { - inst->U.I.PreSub.SrcReg[0] = s->Inst->U.I.SrcReg[0]; - inst->U.I.PreSub.SrcReg[1] = s->Inst->U.I.SrcReg[1]; + inst_reader->U.I.PreSub.SrcReg[0] = inst_add->U.I.SrcReg[0]; + inst_reader->U.I.PreSub.SrcReg[1] = inst_add->U.I.SrcReg[1]; } - inst->U.I.PreSub.SrcReg[0].Negate = 0; - inst->U.I.PreSub.SrcReg[1].Negate = 0; - inst->U.I.PreSub.Opcode = presub_opcode; - inst->U.I.SrcReg[src_index] = chain_srcregs(inst->U.I.SrcReg[src_index], - inst->U.I.PreSub.SrcReg[0]); - inst->U.I.SrcReg[src_index].File = RC_FILE_PRESUB; - inst->U.I.SrcReg[src_index].Index = presub_opcode; + inst_reader->U.I.PreSub.SrcReg[0].Negate = 0; + inst_reader->U.I.PreSub.SrcReg[1].Negate = 0; + inst_reader->U.I.PreSub.Opcode = presub_opcode; + inst_reader->U.I.SrcReg[src_index] = + chain_srcregs(inst_reader->U.I.SrcReg[src_index], + inst_reader->U.I.PreSub.SrcReg[0]); + inst_reader->U.I.SrcReg[src_index].File = RC_FILE_PRESUB; + inst_reader->U.I.SrcReg[src_index].Index = presub_opcode; } -static int is_presub_candidate(struct rc_instruction * inst) +static int is_presub_candidate( + struct radeon_compiler * c, + struct rc_instruction * inst) { const struct rc_opcode_info * info = rc_get_opcode_info(inst->U.I.Opcode); unsigned int i; @@ -565,7 +509,12 @@ static int is_presub_candidate(struct rc_instruction * inst) return 0; for(i = 0; i < info->NumSrcRegs; i++) { - if (src_reads_dst_mask(inst->U.I.SrcReg[i], inst->U.I.DstReg)) + struct rc_src_register src = inst->U.I.SrcReg[i]; + if (src_reads_dst_mask(src, inst->U.I.DstReg)) + return 0; + + src.File = RC_FILE_PRESUB; + if (!c->SwizzleCaps->IsNative(inst->U.I.Opcode, src)) return 0; } return 1; @@ -578,9 +527,8 @@ static int peephole_add_presub_add( struct rc_src_register * src0 = NULL; struct rc_src_register * src1 = NULL; unsigned int i; - struct peephole_state s; - if (!is_presub_candidate(inst_add)) + if (!is_presub_candidate(c, inst_add)) return 0; if (inst_add->U.I.SrcReg[0].Swizzle != inst_add->U.I.SrcReg[1].Swizzle) @@ -604,30 +552,28 @@ static int peephole_add_presub_add( if (!src1) return 0; - s.Inst = inst_add; - s.WriteMask = inst_add->U.I.DstReg.WriteMask; - if (presub_helper(c, &s, RC_PRESUB_ADD, presub_replace_add)) { + if (presub_helper(c, inst_add, RC_PRESUB_ADD, presub_replace_add)) { rc_remove_instruction(inst_add); return 1; } return 0; } -static void presub_replace_inv(struct peephole_state * s, - struct rc_instruction * inst, - unsigned int src_index) +static void presub_replace_inv( + struct rc_instruction * inst_add, + struct rc_instruction * inst_reader, + unsigned int src_index) { - /* We must be careful not to modify s->Inst, since it - * is possible it will remain part of the program. - * XXX Maybe pass a struct instead of a pointer for s->Inst.*/ - inst->U.I.PreSub.SrcReg[0] = s->Inst->U.I.SrcReg[1]; - inst->U.I.PreSub.SrcReg[0].Negate = 0; - inst->U.I.PreSub.Opcode = RC_PRESUB_INV; - inst->U.I.SrcReg[src_index] = chain_srcregs(inst->U.I.SrcReg[src_index], - inst->U.I.PreSub.SrcReg[0]); - - inst->U.I.SrcReg[src_index].File = RC_FILE_PRESUB; - inst->U.I.SrcReg[src_index].Index = RC_PRESUB_INV; + /* We must be careful not to modify inst_add, since it + * is possible it will remain part of the program.*/ + inst_reader->U.I.PreSub.SrcReg[0] = inst_add->U.I.SrcReg[1]; + inst_reader->U.I.PreSub.SrcReg[0].Negate = 0; + inst_reader->U.I.PreSub.Opcode = RC_PRESUB_INV; + inst_reader->U.I.SrcReg[src_index] = chain_srcregs(inst_reader->U.I.SrcReg[src_index], + inst_reader->U.I.PreSub.SrcReg[0]); + + inst_reader->U.I.SrcReg[src_index].File = RC_FILE_PRESUB; + inst_reader->U.I.SrcReg[src_index].Index = RC_PRESUB_INV; } /** @@ -645,9 +591,8 @@ static int peephole_add_presub_inv( struct rc_instruction * inst_add) { unsigned int i, swz, mask; - struct peephole_state s; - if (!is_presub_candidate(inst_add)) + if (!is_presub_candidate(c, inst_add)) return 0; mask = inst_add->U.I.DstReg.WriteMask; @@ -674,11 +619,7 @@ static int peephole_add_presub_inv( return 0; } - /* Setup the peephole_state information. */ - s.Inst = inst_add; - s.WriteMask = inst_add->U.I.DstReg.WriteMask; - - if (presub_helper(c, &s, RC_PRESUB_INV, presub_replace_inv)) { + if (presub_helper(c, inst_add, RC_PRESUB_INV, presub_replace_inv)) { rc_remove_instruction(inst_add); return 1; } diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_pair_regalloc.c b/src/mesa/drivers/dri/r300/compiler/radeon_pair_regalloc.c index 91524f5ec6..3f880c88fa 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_pair_regalloc.c +++ b/src/mesa/drivers/dri/r300/compiler/radeon_pair_regalloc.c @@ -66,10 +66,13 @@ struct regalloc_state { struct hardware_register * HwTemporary; unsigned int NumHwTemporaries; /** - * If an instruction is inside of a loop, end_loop will be the - * IP of the ENDLOOP instruction, otherwise end_loop will be 0 + * If an instruction is inside of a loop, EndLoop will be the + * IP of the ENDLOOP instruction, and BeginLoop will be the IP + * of the BGNLOOP instruction. Otherwise, EndLoop and BeginLoop + * will be -1. */ - int end_loop; + int EndLoop; + int BeginLoop; }; static void print_live_intervals(struct live_intervals * src) @@ -180,11 +183,13 @@ static void scan_callback(void * data, struct rc_instruction * inst, reg->Used = 1; if (file == RC_FILE_INPUT) reg->Live.Start = -1; + else if (s->BeginLoop >= 0) + reg->Live.Start = s->BeginLoop; else reg->Live.Start = inst->IP; reg->Live.End = inst->IP; - } else if (s->end_loop) - reg->Live.End = s->end_loop; + } else if (s->EndLoop >= 0) + reg->Live.End = s->EndLoop; else if (inst->IP > reg->Live.End) reg->Live.End = inst->IP; } @@ -195,6 +200,8 @@ static void compute_live_intervals(struct radeon_compiler *c, memset(s, 0, sizeof(*s)); s->C = c; s->NumHwTemporaries = c->max_temp_regs; + s->BeginLoop = -1; + s->EndLoop = -1; s->HwTemporary = memory_pool_malloc(&c->Pool, s->NumHwTemporaries * sizeof(struct hardware_register)); @@ -207,8 +214,10 @@ static void compute_live_intervals(struct radeon_compiler *c, inst = inst->Next) { /* For all instructions inside of a loop, the ENDLOOP - * instruction is used as the end of the live interval. */ - if (inst->U.I.Opcode == RC_OPCODE_BGNLOOP && !s->end_loop) { + * instruction is used as the end of the live interval and + * the BGNLOOP instruction is used as the beginning. */ + if (inst->U.I.Opcode == RC_OPCODE_BGNLOOP && s->EndLoop < 0) { + s->BeginLoop = inst->IP; int loops = 1; struct rc_instruction * tmp; for(tmp = inst->Next; @@ -219,15 +228,17 @@ static void compute_live_intervals(struct radeon_compiler *c, } else if (tmp->U.I.Opcode == RC_OPCODE_ENDLOOP) { if(!--loops) { - s->end_loop = tmp->IP; + s->EndLoop = tmp->IP; break; } } } } - if (inst->IP == s->end_loop) - s->end_loop = 0; + if (inst->IP == s->EndLoop) { + s->EndLoop = -1; + s->BeginLoop = -1; + } rc_for_all_reads_mask(inst, scan_callback, s); rc_for_all_writes_mask(inst, scan_callback, s); diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_pair_schedule.c b/src/mesa/drivers/dri/r300/compiler/radeon_pair_schedule.c index d4a38607d9..cbb5ef6237 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_pair_schedule.c +++ b/src/mesa/drivers/dri/r300/compiler/radeon_pair_schedule.c @@ -30,6 +30,7 @@ #include <stdio.h> #include "radeon_compiler.h" +#include "radeon_compiler_util.h" #include "radeon_dataflow.h" @@ -54,6 +55,11 @@ struct schedule_instruction { * this instruction can be scheduled. */ unsigned int NumDependencies:5; + + /** List of all readers (see rc_get_readers() for the definition of + * "all readers"), even those outside the basic block this instruction + * lives in. */ + struct rc_reader_data GlobalReaders; }; @@ -94,6 +100,16 @@ struct register_state { struct reg_value * Values[4]; }; +struct remap_reg { + struct rc_instruciont * Inst; + unsigned int OldIndex:(RC_REGISTER_INDEX_BITS+1); + unsigned int OldSwizzle:3; + unsigned int NewIndex:(RC_REGISTER_INDEX_BITS+1); + unsigned int NewSwizzle:3; + unsigned int OnlyTexReads:1; + struct remap_reg * Next; +}; + struct schedule_state { struct radeon_compiler * C; struct schedule_instruction * Current; @@ -126,15 +142,6 @@ static struct reg_value ** get_reg_valuep(struct schedule_state * s, return &s->Temporary[index].Values[chan]; } -static struct reg_value * get_reg_value(struct schedule_state * s, - rc_register_file file, unsigned int index, unsigned int chan) -{ - struct reg_value ** pv = get_reg_valuep(s, file, index, chan); - if (!pv) - return 0; - return *pv; -} - static void add_inst_to_list(struct schedule_instruction ** list, struct schedule_instruction * inst) { inst->NextReady = *list; @@ -290,16 +297,17 @@ static int merge_presub_sources( { unsigned int srcp_src, srcp_regs, is_rgb, is_alpha; struct rc_pair_sub_instruction * dst_sub; + const struct rc_opcode_info * info; assert(dst_full->Alpha.Opcode == RC_OPCODE_NOP); switch(type) { - case RC_PAIR_SOURCE_RGB: + case RC_SOURCE_RGB: is_rgb = 1; is_alpha = 0; dst_sub = &dst_full->RGB; break; - case RC_PAIR_SOURCE_ALPHA: + case RC_SOURCE_ALPHA: is_rgb = 0; is_alpha = 1; dst_sub = &dst_full->Alpha; @@ -309,8 +317,8 @@ static int merge_presub_sources( return 0; } - const struct rc_opcode_info * info = - rc_get_opcode_info(dst_full->RGB.Opcode); + info = rc_get_opcode_info(dst_full->RGB.Opcode); + if (dst_sub->Src[RC_PAIR_PRESUB_SRC].Used) return 0; @@ -340,6 +348,8 @@ static int merge_presub_sources( continue; free_source = rc_pair_alloc_source(dst_full, is_rgb, is_alpha, temp.File, temp.Index); + if (free_source < 0) + return 0; one_way = 1; } else { dst_sub->Src[free_source] = temp; @@ -355,11 +365,11 @@ static int merge_presub_sources( for(arg = 0; arg < info->NumSrcRegs; arg++) { /*If this arg does not read from an rgb source, * do nothing. */ - if (!(rc_source_type_that_arg_reads( - dst_full->RGB.Arg[arg].Source, - dst_full->RGB.Arg[arg].Swizzle) & type)) { + if (!(rc_source_type_swz(dst_full->RGB.Arg[arg].Swizzle, + 3) & type)) { continue; } + if (dst_full->RGB.Arg[arg].Source == srcp_src) dst_full->RGB.Arg[arg].Source = free_source; /* We need to do this just in case register @@ -391,13 +401,13 @@ static int destructive_merge_instructions( /* Merge the rgb presubtract registers. */ if (alpha->RGB.Src[RC_PAIR_PRESUB_SRC].Used) { - if (!merge_presub_sources(rgb, alpha->RGB, RC_PAIR_SOURCE_RGB)) { + if (!merge_presub_sources(rgb, alpha->RGB, RC_SOURCE_RGB)) { return 0; } } /* Merge the alpha presubtract registers */ if (alpha->Alpha.Src[RC_PAIR_PRESUB_SRC].Used) { - if(!merge_presub_sources(rgb, alpha->Alpha, RC_PAIR_SOURCE_ALPHA)){ + if(!merge_presub_sources(rgb, alpha->Alpha, RC_SOURCE_ALPHA)){ return 0; } } @@ -524,6 +534,222 @@ static void presub_nop(struct rc_instruction * emitted) { } } } + +static void rgb_to_alpha_remap ( + struct rc_instruction * inst, + struct rc_pair_instruction_arg * arg, + rc_register_file old_file, + rc_swizzle old_swz, + unsigned int new_index) +{ + int new_src_index; + unsigned int i; + struct rc_pair_instruction_source * old_src = + rc_pair_get_src(&inst->U.P, arg); + if (!old_src) { + return; + } + + for (i = 0; i < 3; i++) { + if (get_swz(arg->Swizzle, i) == old_swz) { + SET_SWZ(arg->Swizzle, i, RC_SWIZZLE_W); + } + } + memset(old_src, 0, sizeof(struct rc_pair_instruction_source)); + new_src_index = rc_pair_alloc_source(&inst->U.P, 0, 1, + old_file, new_index); + /* This conversion is not possible, we must have made a mistake in + * is_rgb_to_alpha_possible. */ + if (new_src_index < 0) { + assert(0); + return; + } + + arg->Source = new_src_index; +} + +static int can_remap(unsigned int opcode) +{ + switch(opcode) { + case RC_OPCODE_DDX: + case RC_OPCODE_DDY: + return 0; + default: + return 1; + } +} + +static int can_convert_opcode_to_alpha(unsigned int opcode) +{ + switch(opcode) { + case RC_OPCODE_DDX: + case RC_OPCODE_DDY: + case RC_OPCODE_DP2: + case RC_OPCODE_DP3: + case RC_OPCODE_DP4: + case RC_OPCODE_DPH: + return 0; + default: + return 1; + } +} + +static void is_rgb_to_alpha_possible( + void * userdata, + struct rc_instruction * inst, + struct rc_pair_instruction_arg * arg, + struct rc_pair_instruction_source * src) +{ + unsigned int chan_count = 0; + unsigned int alpha_sources = 0; + unsigned int i; + struct rc_reader_data * reader_data = userdata; + + if (!can_remap(inst->U.P.RGB.Opcode) + || !can_remap(inst->U.P.Alpha.Opcode)) { + reader_data->Abort = 1; + return; + } + + if (!src) + return; + + /* XXX There are some cases where we can still do the conversion if + * a reader reads from a presubtract source, but for now we'll prevent + * it. */ + if (arg->Source == RC_PAIR_PRESUB_SRC) { + reader_data->Abort = 1; + return; + } + + /* Make sure the source only reads from one component. + * XXX We should allow the source to read from the same component twice. + * XXX If the index we will be converting to is the same as the + * current index, then it is OK to read from more than one component. + */ + for (i = 0; i < 3; i++) { + rc_swizzle swz = get_swz(arg->Swizzle, i); + switch(swz) { + case RC_SWIZZLE_X: + case RC_SWIZZLE_Y: + case RC_SWIZZLE_Z: + case RC_SWIZZLE_W: + chan_count++; + break; + default: + break; + } + } + if (chan_count > 1) { + reader_data->Abort = 1; + return; + } + + /* Make sure there are enough alpha sources. + * XXX If we know what register all the readers are going + * to be remapped to, then in some situations we can still do + * the subsitution, even if all 3 alpha sources are being used.*/ + for (i = 0; i < 3; i++) { + if (inst->U.P.Alpha.Src[i].Used) { + alpha_sources++; + } + } + if (alpha_sources > 2) { + reader_data->Abort = 1; + return; + } +} + +static int convert_rgb_to_alpha( + struct schedule_state * s, + struct schedule_instruction * sched_inst) +{ + struct rc_pair_instruction * pair_inst = &sched_inst->Instruction->U.P; + unsigned int old_mask = pair_inst->RGB.WriteMask; + unsigned int old_swz = rc_mask_to_swizzle(old_mask); + const struct rc_opcode_info * info = + rc_get_opcode_info(pair_inst->RGB.Opcode); + int new_index = -1; + unsigned int i; + + if (sched_inst->GlobalReaders.Abort) + return 0; + + if (!pair_inst->RGB.WriteMask) + return 0; + + if (!can_convert_opcode_to_alpha(pair_inst->RGB.Opcode) + || !can_convert_opcode_to_alpha(pair_inst->Alpha.Opcode)) { + return 0; + } + + assert(sched_inst->NumWriteValues == 1); + + if (!sched_inst->WriteValues[0]) { + assert(0); + return 0; + } + + /* We start at the old index, because if we can reuse the same + * register and just change the swizzle then it is more likely we + * will be able to convert all the readers. */ + for (i = pair_inst->RGB.DestIndex; i < RC_REGISTER_MAX_INDEX; i++) { + struct reg_value ** new_regvalp = get_reg_valuep( + s, RC_FILE_TEMPORARY, i, 3); + if (!*new_regvalp) { + struct reg_value ** old_regvalp = + get_reg_valuep(s, + RC_FILE_TEMPORARY, + pair_inst->RGB.DestIndex, + rc_mask_to_swz(old_mask)); + new_index = i; + *new_regvalp = *old_regvalp; + *old_regvalp = NULL; + new_regvalp = get_reg_valuep(s, RC_FILE_TEMPORARY, i, 3); + break; + } + } + if (new_index < 0) { + return 0; + } + + pair_inst->Alpha.Opcode = pair_inst->RGB.Opcode; + pair_inst->Alpha.DestIndex = new_index; + pair_inst->Alpha.WriteMask = 1; + pair_inst->Alpha.Target = pair_inst->RGB.Target; + pair_inst->Alpha.OutputWriteMask = pair_inst->RGB.OutputWriteMask; + pair_inst->Alpha.DepthWriteMask = pair_inst->RGB.DepthWriteMask; + pair_inst->Alpha.Saturate = pair_inst->RGB.Saturate; + memcpy(pair_inst->Alpha.Arg, pair_inst->RGB.Arg, + sizeof(pair_inst->Alpha.Arg)); + /* Move the swizzles into the first chan */ + for (i = 0; i < info->NumSrcRegs; i++) { + unsigned int j; + for (j = 0; j < 3; j++) { + unsigned int swz = get_swz(pair_inst->Alpha.Arg[i].Swizzle, j); + if (swz != RC_SWIZZLE_UNUSED) { + pair_inst->Alpha.Arg[i].Swizzle = swz; + break; + } + } + } + pair_inst->RGB.Opcode = RC_OPCODE_NOP; + pair_inst->RGB.DestIndex = 0; + pair_inst->RGB.WriteMask = 0; + pair_inst->RGB.Target = 0; + pair_inst->RGB.OutputWriteMask = 0; + pair_inst->RGB.DepthWriteMask = 0; + pair_inst->RGB.Saturate = 0; + memset(pair_inst->RGB.Arg, 0, sizeof(pair_inst->RGB.Arg)); + + for(i = 0; i < sched_inst->GlobalReaders.ReaderCount; i++) { + struct rc_reader reader = sched_inst->GlobalReaders.Readers[i]; + rgb_to_alpha_remap(reader.Inst, reader.U.Arg, + RC_FILE_TEMPORARY, old_swz, new_index); + } + return 1; +} + /** * Find a good ALU instruction or pair of ALU instruction and emit it. * @@ -535,24 +761,16 @@ static void emit_one_alu(struct schedule_state *s, struct rc_instruction * befor { struct schedule_instruction * sinst; - if (s->ReadyFullALU || !(s->ReadyRGB && s->ReadyAlpha)) { - if (s->ReadyFullALU) { - sinst = s->ReadyFullALU; - s->ReadyFullALU = s->ReadyFullALU->NextReady; - } else if (s->ReadyRGB) { - sinst = s->ReadyRGB; - s->ReadyRGB = s->ReadyRGB->NextReady; - } else { - sinst = s->ReadyAlpha; - s->ReadyAlpha = s->ReadyAlpha->NextReady; - } - + if (s->ReadyFullALU) { + sinst = s->ReadyFullALU; + s->ReadyFullALU = s->ReadyFullALU->NextReady; rc_insert_instruction(before->Prev, sinst->Instruction); commit_alu_instruction(s, sinst); } else { struct schedule_instruction **prgb; struct schedule_instruction **palpha; - + struct schedule_instruction *prev; +pair: /* Some pairings might fail because they require too * many source slots; try all possible pairings if necessary */ for(prgb = &s->ReadyRGB; *prgb; prgb = &(*prgb)->NextReady) { @@ -571,10 +789,43 @@ static void emit_one_alu(struct schedule_state *s, struct rc_instruction * befor goto success; } } - - /* No success in pairing; just take the first RGB instruction */ - sinst = s->ReadyRGB; - s->ReadyRGB = s->ReadyRGB->NextReady; + prev = NULL; + /* No success in pairing, now try to convert one of the RGB + * instructions to an Alpha so we can pair it with another RGB. + */ + if (s->ReadyRGB && s->ReadyRGB->NextReady) { + for(prgb = &s->ReadyRGB; *prgb; prgb = &(*prgb)->NextReady) { + if ((*prgb)->NumWriteValues == 1) { + struct schedule_instruction * prgb_next; + if (!convert_rgb_to_alpha(s, *prgb)) + goto cont_loop; + prgb_next = (*prgb)->NextReady; + /* Add instruction to the Alpha ready list. */ + (*prgb)->NextReady = s->ReadyAlpha; + s->ReadyAlpha = *prgb; + /* Remove instruction from the RGB ready list.*/ + if (prev) + prev->NextReady = prgb_next; + else + s->ReadyRGB = prgb_next; + goto pair; + } +cont_loop: + prev = *prgb; + } + } + /* Still no success in pairing, just take the first RGB + * or alpha instruction. */ + if (s->ReadyRGB) { + sinst = s->ReadyRGB; + s->ReadyRGB = s->ReadyRGB->NextReady; + } else if (s->ReadyAlpha) { + sinst = s->ReadyAlpha; + s->ReadyAlpha = s->ReadyAlpha->NextReady; + } else { + /*XXX Something real bad has happened. */ + assert(0); + } rc_insert_instruction(before->Prev, sinst->Instruction); commit_alu_instruction(s, sinst); @@ -590,13 +841,13 @@ static void scan_read(void * data, struct rc_instruction * inst, rc_register_file file, unsigned int index, unsigned int chan) { struct schedule_state * s = data; - struct reg_value * v = get_reg_value(s, file, index, chan); + struct reg_value ** v = get_reg_valuep(s, file, index, chan); struct reg_value_reader * reader; if (!v) return; - if (v->Writer == s->Current) { + if (*v && (*v)->Writer == s->Current) { /* The instruction reads and writes to a register component. * In this case, we only want to increment dependencies by one. */ @@ -607,16 +858,28 @@ static void scan_read(void * data, struct rc_instruction * inst, reader = memory_pool_malloc(&s->C->Pool, sizeof(*reader)); reader->Reader = s->Current; - reader->Next = v->Readers; - v->Readers = reader; - v->NumReaders++; - - s->Current->NumDependencies++; + if (!*v) { + /* In this situation, the instruction reads from a register + * that hasn't been written to or read from in the current + * block. */ + *v = memory_pool_malloc(&s->C->Pool, sizeof(struct reg_value)); + memset(*v, 0, sizeof(struct reg_value)); + (*v)->Readers = reader; + } else { + reader->Next = (*v)->Readers; + (*v)->Readers = reader; + /* Only update the current instruction's dependencies if the + * register it reads from has been written to in this block. */ + if ((*v)->Writer) { + s->Current->NumDependencies++; + } + } + (*v)->NumReaders++; if (s->Current->NumReadValues >= 12) { rc_error(s->C, "%s: NumReadValues overflow\n", __FUNCTION__); } else { - s->Current->ReadValues[s->Current->NumReadValues++] = v; + s->Current->ReadValues[s->Current->NumReadValues++] = *v; } } @@ -651,6 +914,16 @@ static void scan_write(void * data, struct rc_instruction * inst, } } +static void is_rgb_to_alpha_possible_normal( + void * userdata, + struct rc_instruction * inst, + struct rc_src_register * src) +{ + struct rc_reader_data * reader_data = userdata; + reader_data->Abort = 1; + +} + static void schedule_block(struct r300_fragment_program_compiler * c, struct rc_instruction * begin, struct rc_instruction * end) { @@ -682,6 +955,11 @@ static void schedule_block(struct r300_fragment_program_compiler * c, if (!s.Current->NumDependencies) instruction_ready(&s, s.Current); + + /* Get global readers for possible RGB->Alpha conversion. */ + rc_get_readers(s.C, inst, &s.Current->GlobalReaders, + is_rgb_to_alpha_possible_normal, + is_rgb_to_alpha_possible, NULL); } /* Temporarily unlink all instructions */ @@ -710,8 +988,13 @@ static int is_controlflow(struct rc_instruction * inst) void rc_pair_schedule(struct radeon_compiler *cc, void *user) { + struct schedule_state s; + struct r300_fragment_program_compiler *c = (struct r300_fragment_program_compiler*)cc; struct rc_instruction * inst = c->Base.Program.Instructions.Next; + + memset(&s, 0, sizeof(s)); + s.C = &c->Base; while(inst != &c->Base.Program.Instructions) { struct rc_instruction * first; diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_pair_translate.c b/src/mesa/drivers/dri/r300/compiler/radeon_pair_translate.c index c549be5218..fc05366f50 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_pair_translate.c +++ b/src/mesa/drivers/dri/r300/compiler/radeon_pair_translate.c @@ -280,9 +280,12 @@ static void set_pair_instruction(struct r300_fragment_program_compiler *c, pair->RGB.DestIndex = inst->DstReg.Index; pair->RGB.WriteMask |= inst->DstReg.WriteMask & RC_MASK_XYZ; } + if (needalpha) { - pair->Alpha.DestIndex = inst->DstReg.Index; pair->Alpha.WriteMask |= GET_BIT(inst->DstReg.WriteMask, 3); + if (pair->Alpha.WriteMask) { + pair->Alpha.DestIndex = inst->DstReg.Index; + } } } diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_program.c b/src/mesa/drivers/dri/r300/compiler/radeon_program.c index 24b685fbeb..d7bedc5729 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_program.c +++ b/src/mesa/drivers/dri/r300/compiler/radeon_program.c @@ -30,6 +30,7 @@ #include <stdio.h> #include "radeon_compiler.h" +#include "radeon_dataflow.h" /** @@ -91,37 +92,98 @@ struct rc_src_register lmul_swizzle(unsigned int swizzle, struct rc_src_register return tmp; } -unsigned int rc_find_free_temporary(struct radeon_compiler * c) +struct get_used_temporaries_data { + unsigned char * Used; + unsigned int UsedLength; +}; + +static void get_used_temporaries_cb( + void * userdata, + struct rc_instruction * inst, + rc_register_file file, + unsigned int index, + unsigned int mask) { - char used[RC_REGISTER_MAX_INDEX]; - unsigned int i; - struct rc_instruction * rcinst; + struct get_used_temporaries_data * d = userdata; - memset(used, 0, sizeof(used)); + if (file != RC_FILE_TEMPORARY) + return; - for (rcinst = c->Program.Instructions.Next; rcinst != &c->Program.Instructions; rcinst = rcinst->Next) { - const struct rc_sub_instruction *inst = &rcinst->U.I; - const struct rc_opcode_info *opcode = rc_get_opcode_info(inst->Opcode); - unsigned int k; + if (index >= d->UsedLength) + return; - for (k = 0; k < opcode->NumSrcRegs; k++) { - if (inst->SrcReg[k].File == RC_FILE_TEMPORARY) - used[inst->SrcReg[k].Index] = 1; - } + d->Used[index] |= mask; +} - if (opcode->HasDstReg) { - if (inst->DstReg.File == RC_FILE_TEMPORARY) - used[inst->DstReg.Index] = 1; - } +/** + * This function fills in the parameter 'used' with a writemask that + * represent which components of each temporary register are used by the + * program. This is meant to be combined with rc_find_free_temporary_list as a + * more efficient version of rc_find_free_temporary. + * @param used The function does not initialize this parameter. + */ +void rc_get_used_temporaries( + struct radeon_compiler * c, + unsigned char * used, + unsigned int used_length) +{ + struct rc_instruction * inst; + struct get_used_temporaries_data d; + d.Used = used; + d.UsedLength = used_length; + + for(inst = c->Program.Instructions.Next; + inst != &c->Program.Instructions; inst = inst->Next) { + + rc_for_all_reads_mask(inst, get_used_temporaries_cb, &d); + rc_for_all_writes_mask(inst, get_used_temporaries_cb, &d); } +} - for (i = 0; i < RC_REGISTER_MAX_INDEX; i++) { - if (!used[i]) +/* Search a list of used temporaries for a free one + * \sa rc_get_used_temporaries + * @note If this functions finds a free temporary, it will mark it as used + * in the used temporary list (param 'used') + * @param used list of used temporaries + * @param used_length number of items in param 'used' + * @param mask which components must be free in the temporary index that is + * returned. + * @return -1 If there are no more free temporaries, otherwise the index of + * a temporary register where the components specified in param 'mask' are + * not being used. + */ +int rc_find_free_temporary_list( + struct radeon_compiler * c, + unsigned char * used, + unsigned int used_length, + unsigned int mask) +{ + int i; + for(i = 0; i < used_length; i++) { + if ((~used[i] & mask) == mask) { + used[i] |= mask; return i; + } } + return -1; +} - rc_error(c, "Ran out of temporary registers\n"); - return 0; +unsigned int rc_find_free_temporary(struct radeon_compiler * c) +{ + unsigned char used[RC_REGISTER_MAX_INDEX]; + int free; + + memset(used, 0, sizeof(used)); + + rc_get_used_temporaries(c, used, RC_REGISTER_MAX_INDEX); + + free = rc_find_free_temporary_list(c, used, RC_REGISTER_MAX_INDEX, + RC_MASK_XYZW); + if (free < 0) { + rc_error(c, "Ran out of temporary registers\n"); + return 0; + } + return free; } @@ -182,3 +244,14 @@ unsigned int rc_recompute_ips(struct radeon_compiler * c) return ip; } + +rc_swizzle rc_mask_to_swizzle(unsigned int mask) +{ + switch(mask) { + case RC_MASK_X: return RC_SWIZZLE_X; + case RC_MASK_Y: return RC_SWIZZLE_Y; + case RC_MASK_Z: return RC_SWIZZLE_Z; + case RC_MASK_W: return RC_SWIZZLE_W; + default: return RC_SWIZZLE_UNUSED; + } +} diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_program.h b/src/mesa/drivers/dri/r300/compiler/radeon_program.h index f0a77d7b53..be078b4f4f 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_program.h +++ b/src/mesa/drivers/dri/r300/compiler/radeon_program.h @@ -191,6 +191,20 @@ static inline unsigned int combine_swizzles(unsigned int src, unsigned int swz) return ret; } +/** + * @param mask Must be either RC_MASK_X, RC_MASK_Y, RC_MASK_Z, or RC_MASK_W + */ +static inline rc_swizzle rc_mask_to_swz(unsigned int mask) +{ + switch (mask) { + case RC_MASK_X: return RC_SWIZZLE_X; + case RC_MASK_Y: return RC_SWIZZLE_Y; + case RC_MASK_Z: return RC_SWIZZLE_Z; + case RC_MASK_W: return RC_SWIZZLE_W; + default: assert(0); + } + return RC_SWIZZLE_UNUSED; +} struct rc_src_register lmul_swizzle(unsigned int swizzle, struct rc_src_register srcreg); static inline void reset_srcreg(struct rc_src_register* reg) @@ -222,6 +236,17 @@ void rc_local_transform( struct radeon_compiler *c, void *user); +void rc_get_used_temporaries( + struct radeon_compiler * c, + unsigned char * used, + unsigned int used_length); + +int rc_find_free_temporary_list( + struct radeon_compiler * c, + unsigned char * used, + unsigned int used_length, + unsigned int mask); + unsigned int rc_find_free_temporary(struct radeon_compiler * c); struct rc_instruction *rc_alloc_instruction(struct radeon_compiler * c); @@ -233,4 +258,5 @@ unsigned int rc_recompute_ips(struct radeon_compiler * c); void rc_print_program(const struct rc_program *prog); +rc_swizzle rc_mask_to_swizzle(unsigned int mask); #endif diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_program_constants.h b/src/mesa/drivers/dri/r300/compiler/radeon_program_constants.h index 9dcd44c522..45f79ece5b 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_program_constants.h +++ b/src/mesa/drivers/dri/r300/compiler/radeon_program_constants.h @@ -181,4 +181,9 @@ static inline int rc_presubtract_src_reg_count(rc_presubtract_op op){ return 0; } } + +#define RC_SOURCE_NONE 0x0 +#define RC_SOURCE_RGB 0x1 +#define RC_SOURCE_ALPHA 0x2 + #endif /* RADEON_PROGRAM_CONSTANTS_H */ diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_program_pair.c b/src/mesa/drivers/dri/r300/compiler/radeon_program_pair.c index a21fe8d3df..5905d26e52 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_program_pair.c +++ b/src/mesa/drivers/dri/r300/compiler/radeon_program_pair.c @@ -27,6 +27,9 @@ #include "radeon_program_pair.h" +#include "radeon_compiler_util.h" + +#include <stdlib.h> /** * Return the source slot where we installed the given register access, @@ -204,24 +207,37 @@ void rc_pair_foreach_source_that_rgb_reads( } } -/*return 0 for rgb, 1 for alpha -1 for error. */ - -unsigned int rc_source_type_that_arg_reads( - unsigned int source, - unsigned int swizzle) +struct rc_pair_instruction_source * rc_pair_get_src( + struct rc_pair_instruction * pair_inst, + struct rc_pair_instruction_arg * arg) { - unsigned int chan; - unsigned int swz = RC_SWIZZLE_UNUSED; - unsigned int ret = RC_PAIR_SOURCE_NONE; - - for(chan = 0; chan < 3; chan++) { - swz = GET_SWZ(swizzle, chan); - if (swz == RC_SWIZZLE_W) { - ret |= RC_PAIR_SOURCE_ALPHA; - } else if (swz == RC_SWIZZLE_X || swz == RC_SWIZZLE_Y - || swz == RC_SWIZZLE_Z) { - ret |= RC_PAIR_SOURCE_RGB; + unsigned int i, type; + unsigned int channels = 0; + + for(i = 0; i < 3; i++) { + if (arg == pair_inst->RGB.Arg + i) { + channels = 3; + break; } } - return ret; + + if (channels == 0) { + for (i = 0; i < 3; i++) { + if (arg == pair_inst->Alpha.Arg + i) { + channels = 1; + break; + } + } + } + + assert(channels > 0); + type = rc_source_type_swz(arg->Swizzle, channels); + + if (type & RC_SOURCE_RGB) { + return &pair_inst->RGB.Src[arg->Source]; + } else if (type & RC_SOURCE_ALPHA) { + return &pair_inst->Alpha.Src[arg->Source]; + } else { + return NULL; + } } diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_program_pair.h b/src/mesa/drivers/dri/r300/compiler/radeon_program_pair.h index 54d44a2098..ccf7a0070c 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_program_pair.h +++ b/src/mesa/drivers/dri/r300/compiler/radeon_program_pair.h @@ -55,10 +55,6 @@ struct radeon_compiler; */ #define RC_PAIR_PRESUB_SRC 3 -#define RC_PAIR_SOURCE_NONE 0x0 -#define RC_PAIR_SOURCE_RGB 0x1 -#define RC_PAIR_SOURCE_ALPHA 0x2 - struct rc_pair_instruction_source { unsigned int Used:1; unsigned int File:3; @@ -115,9 +111,9 @@ void rc_pair_foreach_source_that_rgb_reads( void * data, rc_pair_foreach_src_fn cb); -unsigned int rc_source_type_that_arg_reads( - unsigned int source, - unsigned int swizzle); +struct rc_pair_instruction_source * rc_pair_get_src( + struct rc_pair_instruction * pair_inst, + struct rc_pair_instruction_arg * arg); /*@}*/ diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_program_print.c b/src/mesa/drivers/dri/r300/compiler/radeon_program_print.c index 618ab5a099..ae13f6742f 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_program_print.c +++ b/src/mesa/drivers/dri/r300/compiler/radeon_program_print.c @@ -129,6 +129,7 @@ static char rc_swizzle_char(unsigned int swz) case RC_SWIZZLE_HALF: return 'H'; case RC_SWIZZLE_UNUSED: return '_'; } + fprintf(stderr, "bad swz: %u\n", swz); return '?'; } diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_rename_regs.c b/src/mesa/drivers/dri/r300/compiler/radeon_rename_regs.c index 60e228be5b..88165f7895 100644 --- a/src/mesa/drivers/dri/r300/compiler/radeon_rename_regs.c +++ b/src/mesa/drivers/dri/r300/compiler/radeon_rename_regs.c @@ -33,100 +33,51 @@ #include "radeon_compiler.h" #include "radeon_dataflow.h" - -struct reg_rename { - int old_index; - int new_index; - int temp_index; -}; - -static void rename_reg(void * data, struct rc_instruction * inst, - rc_register_file * file, unsigned int * index) -{ - struct reg_rename *r = data; - - if(r->old_index == *index && *file == RC_FILE_TEMPORARY) { - *index = r->new_index; - } - else if(r->new_index == *index && *file == RC_FILE_TEMPORARY) { - *index = r->temp_index; - } -} - -static void rename_all( - struct radeon_compiler *c, - struct rc_instruction * start, - unsigned int old, - unsigned int new, - unsigned int temp) -{ - struct rc_instruction * inst; - struct reg_rename r; - r.old_index = old; - r.new_index = new; - r.temp_index = temp; - for(inst = start; inst != &c->Program.Instructions; - inst = inst->Next) { - rc_remap_registers(inst, rename_reg, &r); - } -} +#include "radeon_program.h" /** * This function renames registers in an attempt to get the code close to * SSA form. After this function has completed, most of the register are only - * written to one time, with a few exceptions. For example, this block of code - * will not be modified by this function: - * Mov Temp[0].x Const[0].x - * Mov Temp[0].y Const[0].y - * Basically, destination registers will be renamed if: - * 1. There have been no previous writes to that register - * or - * 2. If the instruction is writting to the exact components (no more, no less) - * of a register that has been written to by previous instructions. + * written to one time, with a few exceptions. * * This function assumes all the instructions are still of type * RC_INSTRUCTION_NORMAL. */ void rc_rename_regs(struct radeon_compiler *c, void *user) { - unsigned int cur_index = 0; - unsigned int icount; + unsigned int i, used_length; + int new_index; struct rc_instruction * inst; - unsigned int * masks; + struct rc_reader_data reader_data; + unsigned char * used; - /* The number of instructions in the program is also the maximum - * number of temp registers that could potentially be used. */ - icount = rc_recompute_ips(c); - masks = memory_pool_malloc(&c->Pool, icount * sizeof(unsigned int)); - memset(masks, 0, icount * sizeof(unsigned int)); + used_length = 2 * rc_recompute_ips(c); + used = memory_pool_malloc(&c->Pool, sizeof(unsigned char) * used_length); + memset(used, 0, sizeof(unsigned char) * used_length); + rc_get_used_temporaries(c, used, used_length); for(inst = c->Program.Instructions.Next; inst != &c->Program.Instructions; inst = inst->Next) { - const struct rc_opcode_info * info; - unsigned int old_index, temp_index; - struct rc_dst_register * dst; - if(inst->Type != RC_INSTRUCTION_NORMAL) { - rc_error(c, "%s only works with normal instructions.", - __FUNCTION__); - return; - } - dst = &inst->U.I.DstReg; - info = rc_get_opcode_info(inst->U.I.Opcode); - if(!info->HasDstReg || dst->File != RC_FILE_TEMPORARY) { + + if (inst->U.I.DstReg.File != RC_FILE_TEMPORARY) continue; + + rc_get_readers(c, inst, &reader_data, NULL, NULL, NULL); + + if (reader_data.Abort || reader_data.ReaderCount == 0) + continue; + + new_index = rc_find_free_temporary_list(c, used, used_length, + RC_MASK_XYZW); + if (new_index < 0) { + rc_error(c, "Ran out of temporary registers\n"); + return; } - if(dst->Index >= icount || !masks[dst->Index] || - masks[dst->Index] == dst->WriteMask) { - old_index = dst->Index; - /* We need to set dst->Index here so get free temporary - * will work. */ - dst->Index = cur_index++; - temp_index = rc_find_free_temporary(c); - rename_all(c, inst->Next, old_index, - dst->Index, temp_index); + + reader_data.Writer->U.I.DstReg.Index = new_index; + for(i = 0; i < reader_data.ReaderCount; i++) { + reader_data.Readers[i].U.Src->Index = new_index; } - assert(dst->Index < icount); - masks[dst->Index] |= dst->WriteMask; } } diff --git a/src/mesa/drivers/dri/r300/r300_context.c b/src/mesa/drivers/dri/r300/r300_context.c index 9fbd36bfe6..c288834d24 100644 --- a/src/mesa/drivers/dri/r300/r300_context.c +++ b/src/mesa/drivers/dri/r300/r300_context.c @@ -86,6 +86,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #define need_GL_EXT_stencil_two_side #define need_GL_ATI_separate_stencil #define need_GL_NV_vertex_program +#define need_GL_OES_EGL_image #include "main/remap_helper.h" @@ -134,6 +135,9 @@ static const struct dri_extension card_extensions[] = { {"GL_MESAX_texture_float", NULL}, {"GL_NV_blend_square", NULL}, {"GL_NV_vertex_program", GL_NV_vertex_program_functions}, +#if FEATURE_OES_EGL_image + {"GL_OES_EGL_image", GL_OES_EGL_image_functions }, +#endif {NULL, NULL} /* *INDENT-ON* */ }; diff --git a/src/mesa/drivers/dri/r300/r300_draw.c b/src/mesa/drivers/dri/r300/r300_draw.c index 81769e1ee5..0c4d8537c6 100644 --- a/src/mesa/drivers/dri/r300/r300_draw.c +++ b/src/mesa/drivers/dri/r300/r300_draw.c @@ -717,6 +717,10 @@ static void r300DrawPrims(struct gl_context *ctx, GLuint max_index) { GLboolean retval; + struct r300_context *r300 = R300_CONTEXT(ctx); + radeonContextPtr radeon = &r300->radeon; + + radeon_prepare_render(radeon); /* This check should get folded into just the places that * min/max index are really needed. diff --git a/src/mesa/drivers/dri/r300/r300_render.c b/src/mesa/drivers/dri/r300/r300_render.c index 821318e7a5..44090ec289 100644 --- a/src/mesa/drivers/dri/r300/r300_render.c +++ b/src/mesa/drivers/dri/r300/r300_render.c @@ -327,8 +327,6 @@ void r300RunRenderPrimitive(struct gl_context * ctx, int start, int end, int pri BATCH_LOCALS(&rmesa->radeon); int type, num_verts; - radeon_prepare_render(&rmesa->radeon); - type = r300PrimitiveType(rmesa, prim); num_verts = r300NumVerts(rmesa, end - start, prim); diff --git a/src/mesa/drivers/dri/r300/r300_tex.c b/src/mesa/drivers/dri/r300/r300_tex.c index a6bda0e499..de66293999 100644 --- a/src/mesa/drivers/dri/r300/r300_tex.c +++ b/src/mesa/drivers/dri/r300/r300_tex.c @@ -382,5 +382,9 @@ void r300InitTextureFuncs(radeonContextPtr radeon, struct dd_function_table *fun functions->GenerateMipmap = radeonGenerateMipmap; +#if FEATURE_OES_EGL_image + functions->EGLImageTargetTexture2D = radeon_image_target_texture_2d; +#endif + driInitTextureFormats(); } diff --git a/src/mesa/drivers/dri/r300/r300_texstate.c b/src/mesa/drivers/dri/r300/r300_texstate.c index 0116c5d2fa..ed9955b05d 100644 --- a/src/mesa/drivers/dri/r300/r300_texstate.c +++ b/src/mesa/drivers/dri/r300/r300_texstate.c @@ -428,6 +428,7 @@ void r300SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint texture_format radeonTexObjPtr t; uint32_t pitch_val; uint32_t internalFormat, type, format; + gl_format texFormat; type = GL_BGRA; format = GL_UNSIGNED_BYTE; @@ -467,9 +468,6 @@ void r300SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint texture_format radeon_miptree_unreference(&t->mt); radeon_miptree_unreference(&rImage->mt); - _mesa_init_teximage_fields(radeon->glCtx, target, texImage, - rb->base.Width, rb->base.Height, 1, 0, rb->cpp); - texImage->RowStride = rb->pitch / rb->cpp; rImage->bo = rb->bo; radeon_bo_ref(rImage->bo); t->bo = rb->bo; @@ -481,22 +479,35 @@ void r300SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint texture_format pitch_val = rb->pitch; switch (rb->cpp) { case 4: - if (texture_format == __DRI_TEXTURE_FORMAT_RGB) + if (texture_format == __DRI_TEXTURE_FORMAT_RGB) { + texFormat = MESA_FORMAT_RGB888; t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8); - else + } + else { + texFormat = MESA_FORMAT_ARGB8888; t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8); + } pitch_val /= 4; break; case 3: default: + texFormat = MESA_FORMAT_RGB888; t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8); pitch_val /= 4; break; case 2: + texFormat = MESA_FORMAT_RGB565; t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5); pitch_val /= 2; break; } + + _mesa_init_teximage_fields(radeon->glCtx, target, texImage, + rb->base.Width, rb->base.Height, 1, 0, + rb->cpp, texFormat); + texImage->RowStride = rb->pitch / rb->cpp; + + pitch_val--; t->pp_txsize = (((R300_TX_WIDTHMASK_MASK & ((rb->base.Width - 1) << R300_TX_WIDTHMASK_SHIFT))) | ((R300_TX_HEIGHTMASK_MASK & ((rb->base.Height - 1) << R300_TX_HEIGHTMASK_SHIFT)))); diff --git a/src/mesa/drivers/dri/r600/evergreen_render.c b/src/mesa/drivers/dri/r600/evergreen_render.c index 0c0eeca1fc..6e51832c87 100644 --- a/src/mesa/drivers/dri/r600/evergreen_render.c +++ b/src/mesa/drivers/dri/r600/evergreen_render.c @@ -909,6 +909,10 @@ static void evergreenDrawPrims(struct gl_context *ctx, { GLboolean retval = GL_FALSE; + context_t *context = EVERGREEN_CONTEXT(ctx); + radeonContextPtr radeon = &context->radeon; + radeon_prepare_render(radeon); + /* This check should get folded into just the places that * min/max index are really needed. */ diff --git a/src/mesa/drivers/dri/r600/evergreen_tex.c b/src/mesa/drivers/dri/r600/evergreen_tex.c index 58420ed123..3b5448a0e4 100644 --- a/src/mesa/drivers/dri/r600/evergreen_tex.c +++ b/src/mesa/drivers/dri/r600/evergreen_tex.c @@ -31,9 +31,7 @@ #include "main/enums.h" #include "main/image.h" #include "main/teximage.h" -#include "main/mipmap.h" #include "main/simple_list.h" -#include "main/texstore.h" #include "main/texobj.h" #include "texmem.h" @@ -1024,15 +1022,15 @@ static GLboolean evergreen_setup_hardware_state(struct gl_context * ctx, struct SETfield(t->SQ_TEX_RESOURCE5, t->maxLod - t->minLod, LAST_LEVEL_shift, LAST_LEVEL_mask); SETfield(t->SQ_TEX_SAMPLER1, - EG_S_FIXED(CLAMP(t->base.MinLod - t->minLod, 0, 15), 6), + EG_S_FIXED(CLAMP(t->base.MinLod - t->minLod, 0, 15), 8), EG_SQ_TEX_SAMPLER_WORD1_0__MIN_LOD_shift, EG_SQ_TEX_SAMPLER_WORD1_0__MIN_LOD_mask); SETfield(t->SQ_TEX_SAMPLER1, - EG_S_FIXED(CLAMP(t->base.MaxLod - t->minLod, 0, 15), 6), + EG_S_FIXED(CLAMP(t->base.MaxLod - t->minLod, 0, 15), 8), EG_SQ_TEX_SAMPLER_WORD1_0__MAX_LOD_shift, EG_SQ_TEX_SAMPLER_WORD1_0__MAX_LOD_mask); SETfield(t->SQ_TEX_SAMPLER2, - EG_S_FIXED(CLAMP(ctx->Texture.Unit[unit].LodBias + t->base.LodBias, -16, 16), 6), + EG_S_FIXED(CLAMP(ctx->Texture.Unit[unit].LodBias + t->base.LodBias, -16, 16), 8), EG_SQ_TEX_SAMPLER_WORD2_0__LOD_BIAS_shift, EG_SQ_TEX_SAMPLER_WORD2_0__LOD_BIAS_mask); @@ -1152,6 +1150,7 @@ void evergreenSetTexBuffer(__DRIcontext *pDRICtx, GLint target, GLint glx_textur radeonTexObjPtr t; uint32_t pitch_val; uint32_t internalFormat, type, format; + gl_format texFormat; type = GL_BGRA; format = GL_UNSIGNED_BYTE; @@ -1191,10 +1190,6 @@ void evergreenSetTexBuffer(__DRIcontext *pDRICtx, GLint target, GLint glx_textur radeon_miptree_unreference(&t->mt); radeon_miptree_unreference(&rImage->mt); - _mesa_init_teximage_fields(radeon->glCtx, target, texImage, - rb->base.Width, rb->base.Height, 1, 0, rb->cpp); - texImage->RowStride = rb->pitch / rb->cpp; - rImage->bo = rb->bo; radeon_bo_ref(rImage->bo); t->bo = rb->bo; @@ -1205,6 +1200,7 @@ void evergreenSetTexBuffer(__DRIcontext *pDRICtx, GLint target, GLint glx_textur switch (rb->cpp) { case 4: if (glx_texture_format == __DRI_TEXTURE_FORMAT_RGB) { + texFormat = MESA_FORMAT_RGB888; SETfield(t->SQ_TEX_RESOURCE7, FMT_8_8_8_8, EG_SQ_TEX_RESOURCE_WORD7_0__DATA_FORMAT_shift, EG_SQ_TEX_RESOURCE_WORD7_0__DATA_FORMAT_mask); @@ -1218,6 +1214,7 @@ void evergreenSetTexBuffer(__DRIcontext *pDRICtx, GLint target, GLint glx_textur SETfield(t->SQ_TEX_RESOURCE4, SQ_SEL_1, SQ_TEX_RESOURCE_WORD4_0__DST_SEL_W_shift, SQ_TEX_RESOURCE_WORD4_0__DST_SEL_W_mask); } else { + texFormat = MESA_FORMAT_ARGB8888; SETfield(t->SQ_TEX_RESOURCE7, FMT_8_8_8_8, EG_SQ_TEX_RESOURCE_WORD7_0__DATA_FORMAT_shift, EG_SQ_TEX_RESOURCE_WORD7_0__DATA_FORMAT_mask); @@ -1236,6 +1233,7 @@ void evergreenSetTexBuffer(__DRIcontext *pDRICtx, GLint target, GLint glx_textur case 3: default: // FMT_8_8_8 ??? + texFormat = MESA_FORMAT_RGB888; SETfield(t->SQ_TEX_RESOURCE7, FMT_8_8_8_8, EG_SQ_TEX_RESOURCE_WORD7_0__DATA_FORMAT_shift, EG_SQ_TEX_RESOURCE_WORD7_0__DATA_FORMAT_mask); @@ -1251,6 +1249,7 @@ void evergreenSetTexBuffer(__DRIcontext *pDRICtx, GLint target, GLint glx_textur pitch_val /= 4; break; case 2: + texFormat = MESA_FORMAT_RGB565; SETfield(t->SQ_TEX_RESOURCE7, FMT_5_6_5, EG_SQ_TEX_RESOURCE_WORD7_0__DATA_FORMAT_shift, EG_SQ_TEX_RESOURCE_WORD7_0__DATA_FORMAT_mask); @@ -1267,6 +1266,11 @@ void evergreenSetTexBuffer(__DRIcontext *pDRICtx, GLint target, GLint glx_textur break; } + _mesa_init_teximage_fields(radeon->glCtx, target, texImage, + rb->base.Width, rb->base.Height, 1, 0, + rb->cpp, texFormat); + texImage->RowStride = rb->pitch / rb->cpp; + pitch_val = (pitch_val + R700_TEXEL_PITCH_ALIGNMENT_MASK) & ~R700_TEXEL_PITCH_ALIGNMENT_MASK; diff --git a/src/mesa/drivers/dri/r600/r600_context.c b/src/mesa/drivers/dri/r600/r600_context.c index c882a9cce9..b6443bf0c5 100644 --- a/src/mesa/drivers/dri/r600/r600_context.c +++ b/src/mesa/drivers/dri/r600/r600_context.c @@ -94,6 +94,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #define need_GL_EXT_stencil_two_side #define need_GL_ATI_separate_stencil #define need_GL_NV_vertex_program +#define need_GL_OES_EGL_image #include "main/remap_helper.h" @@ -148,6 +149,9 @@ static const struct dri_extension card_extensions[] = { {"GL_NV_vertex_program", GL_NV_vertex_program_functions}, {"GL_ARB_pixel_buffer_object", NULL}, {"GL_ARB_draw_elements_base_vertex", GL_ARB_draw_elements_base_vertex_functions }, +#if FEATURE_OES_EGL_image + {"GL_OES_EGL_image", GL_OES_EGL_image_functions}, +#endif {NULL, NULL} /* *INDENT-ON* */ }; diff --git a/src/mesa/drivers/dri/r600/r600_tex.c b/src/mesa/drivers/dri/r600/r600_tex.c index d6a58f410c..c3d68c41e5 100644 --- a/src/mesa/drivers/dri/r600/r600_tex.c +++ b/src/mesa/drivers/dri/r600/r600_tex.c @@ -475,5 +475,9 @@ void r600InitTextureFuncs(radeonContextPtr radeon, struct dd_function_table *fun functions->GenerateMipmap = radeonGenerateMipmap; +#if FEATURE_OES_EGL_image + functions->EGLImageTargetTexture2D = radeon_image_target_texture_2d; +#endif + driInitTextureFormats(); } diff --git a/src/mesa/drivers/dri/r600/r600_texstate.c b/src/mesa/drivers/dri/r600/r600_texstate.c index 3869768bf0..aafa687577 100644 --- a/src/mesa/drivers/dri/r600/r600_texstate.c +++ b/src/mesa/drivers/dri/r600/r600_texstate.c @@ -1001,6 +1001,7 @@ void r600SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint glx_texture_fo radeonTexObjPtr t; uint32_t pitch_val; uint32_t internalFormat, type, format; + gl_format texFormat; type = GL_BGRA; format = GL_UNSIGNED_BYTE; @@ -1046,10 +1047,6 @@ void r600SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint glx_texture_fo radeon_miptree_unreference(&t->mt); radeon_miptree_unreference(&rImage->mt); - _mesa_init_teximage_fields(radeon->glCtx, target, texImage, - rb->base.Width, rb->base.Height, 1, 0, rb->cpp); - texImage->RowStride = rb->pitch / rb->cpp; - rImage->bo = rb->bo; radeon_bo_ref(rImage->bo); t->bo = rb->bo; @@ -1060,6 +1057,7 @@ void r600SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint glx_texture_fo switch (rb->cpp) { case 4: if (glx_texture_format == __DRI_TEXTURE_FORMAT_RGB) { + texFormat = MESA_FORMAT_RGB888; SETfield(t->SQ_TEX_RESOURCE1, FMT_8_8_8_8, SQ_TEX_RESOURCE_WORD1_0__DATA_FORMAT_shift, SQ_TEX_RESOURCE_WORD1_0__DATA_FORMAT_mask); @@ -1072,6 +1070,7 @@ void r600SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint glx_texture_fo SETfield(t->SQ_TEX_RESOURCE4, SQ_SEL_1, SQ_TEX_RESOURCE_WORD4_0__DST_SEL_W_shift, SQ_TEX_RESOURCE_WORD4_0__DST_SEL_W_mask); } else { + texFormat = MESA_FORMAT_ARGB8888; SETfield(t->SQ_TEX_RESOURCE1, FMT_8_8_8_8, SQ_TEX_RESOURCE_WORD1_0__DATA_FORMAT_shift, SQ_TEX_RESOURCE_WORD1_0__DATA_FORMAT_mask); @@ -1089,6 +1088,7 @@ void r600SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint glx_texture_fo case 3: default: // FMT_8_8_8 ??? + texFormat = MESA_FORMAT_RGB888; SETfield(t->SQ_TEX_RESOURCE1, FMT_8_8_8_8, SQ_TEX_RESOURCE_WORD1_0__DATA_FORMAT_shift, SQ_TEX_RESOURCE_WORD1_0__DATA_FORMAT_mask); @@ -1103,6 +1103,7 @@ void r600SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint glx_texture_fo pitch_val /= 4; break; case 2: + texFormat = MESA_FORMAT_RGB565; SETfield(t->SQ_TEX_RESOURCE1, FMT_5_6_5, SQ_TEX_RESOURCE_WORD1_0__DATA_FORMAT_shift, SQ_TEX_RESOURCE_WORD1_0__DATA_FORMAT_mask); @@ -1118,6 +1119,11 @@ void r600SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint glx_texture_fo break; } + _mesa_init_teximage_fields(radeon->glCtx, target, texImage, + rb->base.Width, rb->base.Height, 1, 0, + rb->cpp, texFormat); + texImage->RowStride = rb->pitch / rb->cpp; + pitch_val = (pitch_val + R700_TEXEL_PITCH_ALIGNMENT_MASK) & ~R700_TEXEL_PITCH_ALIGNMENT_MASK; diff --git a/src/mesa/drivers/dri/radeon/radeon_common.c b/src/mesa/drivers/dri/radeon/radeon_common.c index 43a6355ad8..7361adffcf 100644 --- a/src/mesa/drivers/dri/radeon/radeon_common.c +++ b/src/mesa/drivers/dri/radeon/radeon_common.c @@ -171,6 +171,10 @@ void radeonSetCliprects(radeonContextPtr radeon) { __DRIdrawable *const drawable = radeon_get_drawable(radeon); __DRIdrawable *const readable = radeon_get_readable(radeon); + + if(drawable == NULL && readable == NULL) + return; + struct radeon_framebuffer *const draw_rfb = drawable->driverPrivate; struct radeon_framebuffer *const read_rfb = readable->driverPrivate; int x_off, y_off; diff --git a/src/mesa/drivers/dri/radeon/radeon_common_context.c b/src/mesa/drivers/dri/radeon/radeon_common_context.c index 40544860b3..fecdd11905 100644 --- a/src/mesa/drivers/dri/radeon/radeon_common_context.c +++ b/src/mesa/drivers/dri/radeon/radeon_common_context.c @@ -39,6 +39,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include "drirenderbuffer.h" #include "drivers/common/meta.h" #include "main/context.h" +#include "main/framebuffer.h" #include "main/renderbuffer.h" #include "main/state.h" #include "main/simple_list.h" @@ -245,16 +246,9 @@ GLboolean radeonInitContext(radeonContextPtr radeon, DRI_CONF_TEXTURE_DEPTH_32 : DRI_CONF_TEXTURE_DEPTH_16; if (IS_R600_CLASS(radeon->radeonScreen)) { - int chip_family = radeon->radeonScreen->chip_family; - if (chip_family >= CHIP_FAMILY_CEDAR) { - radeon->texture_row_align = 512; - radeon->texture_rect_row_align = 512; - radeon->texture_compressed_row_align = 512; - } else { - radeon->texture_row_align = 256; - radeon->texture_rect_row_align = 256; - radeon->texture_compressed_row_align = 256; - } + radeon->texture_row_align = radeon->radeonScreen->group_bytes; + radeon->texture_rect_row_align = radeon->radeonScreen->group_bytes; + radeon->texture_compressed_row_align = radeon->radeonScreen->group_bytes; } else if (IS_R200_CLASS(radeon->radeonScreen) || IS_R100_CLASS(radeon->radeonScreen)) { radeon->texture_row_align = 32; @@ -379,12 +373,12 @@ GLboolean radeonUnbindContext(__DRIcontext * driContextPriv) static void radeon_make_kernel_renderbuffer_current(radeonContextPtr radeon, - struct radeon_framebuffer *draw) + struct gl_framebuffer *draw) { /* if radeon->fake */ struct radeon_renderbuffer *rb; - if ((rb = (void *)draw->base.Attachment[BUFFER_FRONT_LEFT].Renderbuffer)) { + if ((rb = (void *)draw->Attachment[BUFFER_FRONT_LEFT].Renderbuffer)) { if (!rb->bo) { rb->bo = radeon_bo_open(radeon->radeonScreen->bom, radeon->radeonScreen->frontOffset, @@ -396,7 +390,7 @@ radeon_make_kernel_renderbuffer_current(radeonContextPtr radeon, rb->cpp = radeon->radeonScreen->cpp; rb->pitch = radeon->radeonScreen->frontPitch * rb->cpp; } - if ((rb = (void *)draw->base.Attachment[BUFFER_BACK_LEFT].Renderbuffer)) { + if ((rb = (void *)draw->Attachment[BUFFER_BACK_LEFT].Renderbuffer)) { if (!rb->bo) { rb->bo = radeon_bo_open(radeon->radeonScreen->bom, radeon->radeonScreen->backOffset, @@ -408,7 +402,7 @@ radeon_make_kernel_renderbuffer_current(radeonContextPtr radeon, rb->cpp = radeon->radeonScreen->cpp; rb->pitch = radeon->radeonScreen->backPitch * rb->cpp; } - if ((rb = (void *)draw->base.Attachment[BUFFER_DEPTH].Renderbuffer)) { + if ((rb = (void *)draw->Attachment[BUFFER_DEPTH].Renderbuffer)) { if (!rb->bo) { rb->bo = radeon_bo_open(radeon->radeonScreen->bom, radeon->radeonScreen->depthOffset, @@ -420,7 +414,7 @@ radeon_make_kernel_renderbuffer_current(radeonContextPtr radeon, rb->cpp = radeon->radeonScreen->cpp; rb->pitch = radeon->radeonScreen->depthPitch * rb->cpp; } - if ((rb = (void *)draw->base.Attachment[BUFFER_STENCIL].Renderbuffer)) { + if ((rb = (void *)draw->Attachment[BUFFER_STENCIL].Renderbuffer)) { if (!rb->bo) { rb->bo = radeon_bo_open(radeon->radeonScreen->bom, radeon->radeonScreen->depthOffset, @@ -436,7 +430,7 @@ radeon_make_kernel_renderbuffer_current(radeonContextPtr radeon, static void radeon_make_renderbuffer_current(radeonContextPtr radeon, - struct radeon_framebuffer *draw) + struct gl_framebuffer *draw) { int size = 4096*4096*4; /* if radeon->fake */ @@ -448,7 +442,7 @@ radeon_make_renderbuffer_current(radeonContextPtr radeon, } - if ((rb = (void *)draw->base.Attachment[BUFFER_FRONT_LEFT].Renderbuffer)) { + if ((rb = (void *)draw->Attachment[BUFFER_FRONT_LEFT].Renderbuffer)) { if (!rb->bo) { rb->bo = radeon_bo_open(radeon->radeonScreen->bom, radeon->radeonScreen->frontOffset + @@ -461,7 +455,7 @@ radeon_make_renderbuffer_current(radeonContextPtr radeon, rb->cpp = radeon->radeonScreen->cpp; rb->pitch = radeon->radeonScreen->frontPitch * rb->cpp; } - if ((rb = (void *)draw->base.Attachment[BUFFER_BACK_LEFT].Renderbuffer)) { + if ((rb = (void *)draw->Attachment[BUFFER_BACK_LEFT].Renderbuffer)) { if (!rb->bo) { rb->bo = radeon_bo_open(radeon->radeonScreen->bom, radeon->radeonScreen->backOffset + @@ -474,7 +468,7 @@ radeon_make_renderbuffer_current(radeonContextPtr radeon, rb->cpp = radeon->radeonScreen->cpp; rb->pitch = radeon->radeonScreen->backPitch * rb->cpp; } - if ((rb = (void *)draw->base.Attachment[BUFFER_DEPTH].Renderbuffer)) { + if ((rb = (void *)draw->Attachment[BUFFER_DEPTH].Renderbuffer)) { if (!rb->bo) { rb->bo = radeon_bo_open(radeon->radeonScreen->bom, radeon->radeonScreen->depthOffset + @@ -487,7 +481,7 @@ radeon_make_renderbuffer_current(radeonContextPtr radeon, rb->cpp = radeon->radeonScreen->cpp; rb->pitch = radeon->radeonScreen->depthPitch * rb->cpp; } - if ((rb = (void *)draw->base.Attachment[BUFFER_STENCIL].Renderbuffer)) { + if ((rb = (void *)draw->Attachment[BUFFER_STENCIL].Renderbuffer)) { if (!rb->bo) { rb->bo = radeon_bo_open(radeon->radeonScreen->bom, radeon->radeonScreen->depthOffset + @@ -740,10 +734,9 @@ radeon_update_renderbuffers(__DRIcontext *context, __DRIdrawable *drawable, buffers[i].flags); if (bo == NULL) { - fprintf(stderr, "failed to attach %s %d\n", regname, buffers[i].name); - + continue; } ret = radeon_bo_get_tiling(bo, &tiling_flags, &pitch); @@ -793,8 +786,8 @@ GLboolean radeonMakeCurrent(__DRIcontext * driContextPriv, __DRIdrawable * driReadPriv) { radeonContextPtr radeon; - struct radeon_framebuffer *drfb; - struct gl_framebuffer *readfb; + struct radeon_framebuffer *rdrfb; + struct gl_framebuffer *drfb, *readfb; if (!driContextPriv) { if (RADEON_DEBUG & RADEON_DRI) @@ -804,17 +797,25 @@ GLboolean radeonMakeCurrent(__DRIcontext * driContextPriv, } radeon = (radeonContextPtr) driContextPriv->driverPrivate; - drfb = driDrawPriv->driverPrivate; - readfb = driReadPriv->driverPrivate; + + if(driDrawPriv == NULL && driReadPriv == NULL) { + drfb = _mesa_create_framebuffer(&radeon->glCtx->Visual); + readfb = drfb; + } + else { + drfb = driDrawPriv->driverPrivate; + readfb = driReadPriv->driverPrivate; + } if (driContextPriv->driScreenPriv->dri2.enabled) { - radeon_update_renderbuffers(driContextPriv, driDrawPriv, GL_FALSE); + if(driDrawPriv) + radeon_update_renderbuffers(driContextPriv, driDrawPriv, GL_FALSE); if (driDrawPriv != driReadPriv) radeon_update_renderbuffers(driContextPriv, driReadPriv, GL_FALSE); _mesa_reference_renderbuffer(&radeon->state.color.rb, - &(radeon_get_renderbuffer(&drfb->base, BUFFER_BACK_LEFT)->base)); + &(radeon_get_renderbuffer(drfb, BUFFER_BACK_LEFT)->base)); _mesa_reference_renderbuffer(&radeon->state.depth.rb, - &(radeon_get_renderbuffer(&drfb->base, BUFFER_DEPTH)->base)); + &(radeon_get_renderbuffer(drfb, BUFFER_DEPTH)->base)); } else { radeon_make_renderbuffer_current(radeon, drfb); } @@ -822,35 +823,40 @@ GLboolean radeonMakeCurrent(__DRIcontext * driContextPriv, if (RADEON_DEBUG & RADEON_DRI) fprintf(stderr, "%s ctx %p dfb %p rfb %p\n", __FUNCTION__, radeon->glCtx, drfb, readfb); - driUpdateFramebufferSize(radeon->glCtx, driDrawPriv); + if(driDrawPriv) + driUpdateFramebufferSize(radeon->glCtx, driDrawPriv); if (driReadPriv != driDrawPriv) driUpdateFramebufferSize(radeon->glCtx, driReadPriv); - _mesa_make_current(radeon->glCtx, &drfb->base, readfb); + _mesa_make_current(radeon->glCtx, drfb, readfb); + if (driDrawPriv == NULL && driReadPriv == NULL) + _mesa_reference_framebuffer(&drfb, NULL); _mesa_update_state(radeon->glCtx); - if (radeon->glCtx->DrawBuffer == &drfb->base) { - if (driDrawPriv->swap_interval == (unsigned)-1) { - int i; - driDrawPriv->vblFlags = - (radeon->radeonScreen->irq != 0) - ? driGetDefaultVBlankFlags(&radeon-> - optionCache) - : VBLANK_FLAG_NO_IRQ; - - driDrawableInitVBlank(driDrawPriv); - drfb->vbl_waited = driDrawPriv->vblSeq; - - for (i = 0; i < 2; i++) { - if (drfb->color_rb[i]) - drfb->color_rb[i]->vbl_pending = driDrawPriv->vblSeq; + if (radeon->glCtx->DrawBuffer == drfb) { + if(driDrawPriv != NULL) { + rdrfb = (struct radeon_framebuffer *)drfb; + if (driDrawPriv->swap_interval == (unsigned)-1) { + int i; + driDrawPriv->vblFlags = + (radeon->radeonScreen->irq != 0) + ? driGetDefaultVBlankFlags(&radeon-> + optionCache) + : VBLANK_FLAG_NO_IRQ; + + driDrawableInitVBlank(driDrawPriv); + rdrfb->vbl_waited = driDrawPriv->vblSeq; + + for (i = 0; i < 2; i++) { + if (rdrfb->color_rb[i]) + rdrfb->color_rb[i]->vbl_pending = driDrawPriv->vblSeq; + } } - + radeon_window_moved(radeon); } - radeon_window_moved(radeon); - radeon_draw_buffer(radeon->glCtx, &drfb->base); + radeon_draw_buffer(radeon->glCtx, drfb); } diff --git a/src/mesa/drivers/dri/radeon/radeon_context.c b/src/mesa/drivers/dri/radeon/radeon_context.c index cc9590213c..e3de534b5f 100644 --- a/src/mesa/drivers/dri/radeon/radeon_context.c +++ b/src/mesa/drivers/dri/radeon/radeon_context.c @@ -66,6 +66,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #define need_GL_EXT_fog_coord #define need_GL_EXT_secondary_color #define need_GL_EXT_framebuffer_object +#define need_GL_OES_EGL_image #include "main/remap_helper.h" #define DRIVER_DATE "20061018" @@ -101,6 +102,9 @@ static const struct dri_extension card_extensions[] = { "GL_ATI_texture_mirror_once", NULL }, { "GL_MESA_ycbcr_texture", NULL }, { "GL_NV_blend_square", NULL }, +#if FEATURE_OES_EGL_image + { "GL_OES_EGL_image", GL_OES_EGL_image_functions }, +#endif { NULL, NULL } }; diff --git a/src/mesa/drivers/dri/radeon/radeon_fbo.c b/src/mesa/drivers/dri/radeon/radeon_fbo.c index 2a6fbaeaf0..a36a1dc94a 100644 --- a/src/mesa/drivers/dri/radeon/radeon_fbo.c +++ b/src/mesa/drivers/dri/radeon/radeon_fbo.c @@ -199,6 +199,48 @@ radeon_alloc_renderbuffer_storage(struct gl_context * ctx, struct gl_renderbuffe } +#if FEATURE_OES_EGL_image +static void +radeon_image_target_renderbuffer_storage(struct gl_context *ctx, + struct gl_renderbuffer *rb, + void *image_handle) +{ + radeonContextPtr radeon = RADEON_CONTEXT(ctx); + struct radeon_renderbuffer *rrb; + __DRIscreen *screen; + __DRIimage *image; + + screen = radeon->radeonScreen->driScreen; + image = screen->dri2.image->lookupEGLImage(screen, image_handle, + screen->loaderPrivate); + if (image == NULL) + return; + + rrb = radeon_renderbuffer(rb); + + if (ctx->Driver.Flush) + ctx->Driver.Flush(ctx); /* +r6/r7 */ + + if (rrb->bo) + radeon_bo_unref(rrb->bo); + rrb->bo = image->bo; + radeon_bo_ref(rrb->bo); + fprintf(stderr, "image->bo: %p, name: %d, rbs: w %d -> p %d\n", image->bo, image->bo->handle, + image->width, image->pitch); + + rrb->cpp = image->cpp; + rrb->pitch = image->pitch * image->cpp; + + rb->Format = image->format; + rb->InternalFormat = image->internal_format; + rb->Width = image->width; + rb->Height = image->height; + rb->Format = image->format; + rb->DataType = image->data_type; + rb->_BaseFormat = _mesa_base_fbo_format(radeon->glCtx, + image->internal_format); +} +#endif /** * Called for each hardware renderbuffer when a _window_ is resized. @@ -622,6 +664,10 @@ void radeon_fbo_init(struct radeon_context *radeon) #if FEATURE_EXT_framebuffer_blit radeon->glCtx->Driver.BlitFramebuffer = _mesa_meta_BlitFramebuffer; #endif +#if FEATURE_OES_EGL_image + radeon->glCtx->Driver.EGLImageTargetRenderbufferStorage = + radeon_image_target_renderbuffer_storage; +#endif } diff --git a/src/mesa/drivers/dri/radeon/radeon_screen.c b/src/mesa/drivers/dri/radeon/radeon_screen.c index 43ebc81093..b379240579 100644 --- a/src/mesa/drivers/dri/radeon/radeon_screen.c +++ b/src/mesa/drivers/dri/radeon/radeon_screen.c @@ -41,12 +41,14 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include "main/mtypes.h" #include "main/framebuffer.h" #include "main/renderbuffer.h" +#include "main/fbobject.h" #define STANDALONE_MMIO #include "radeon_chipset.h" #include "radeon_macros.h" #include "radeon_screen.h" #include "radeon_common.h" +#include "radeon_common_context.h" #if defined(RADEON_R100) #include "radeon_context.h" #include "radeon_tex.h" @@ -398,6 +400,188 @@ static const struct __DRI2flushExtensionRec radeonFlushExtension = { dri2InvalidateDrawable, }; +static __DRIimage * +radeon_create_image_from_name(__DRIcontext *context, + int width, int height, int format, + int name, int pitch, void *loaderPrivate) +{ + __DRIimage *image; + radeonContextPtr radeon = context->driverPrivate; + + if (name == 0) + return NULL; + + image = CALLOC(sizeof *image); + if (image == NULL) + return NULL; + + switch (format) { + case __DRI_IMAGE_FORMAT_RGB565: + image->format = MESA_FORMAT_RGB565; + image->internal_format = GL_RGB; + image->data_type = GL_UNSIGNED_BYTE; + break; + case __DRI_IMAGE_FORMAT_XRGB8888: + image->format = MESA_FORMAT_XRGB8888; + image->internal_format = GL_RGB; + image->data_type = GL_UNSIGNED_BYTE; + break; + case __DRI_IMAGE_FORMAT_ARGB8888: + image->format = MESA_FORMAT_ARGB8888; + image->internal_format = GL_RGBA; + image->data_type = GL_UNSIGNED_BYTE; + break; + default: + free(image); + return NULL; + } + + image->data = loaderPrivate; + image->cpp = _mesa_get_format_bytes(image->format); + image->width = width; + image->pitch = pitch; + image->height = height; + + image->bo = radeon_bo_open(radeon->radeonScreen->bom, + (uint32_t)name, + image->pitch * image->height * image->cpp, + 0, + RADEON_GEM_DOMAIN_VRAM, + 0); + + if (image->bo == NULL) { + FREE(image); + return NULL; + } + + return image; +} + +static __DRIimage * +radeon_create_image_from_renderbuffer(__DRIcontext *context, + int renderbuffer, void *loaderPrivate) +{ + __DRIimage *image; + radeonContextPtr radeon = context->driverPrivate; + struct gl_renderbuffer *rb; + struct radeon_renderbuffer *rrb; + + rb = _mesa_lookup_renderbuffer(radeon->glCtx, renderbuffer); + if (!rb) { + _mesa_error(radeon->glCtx, + GL_INVALID_OPERATION, "glRenderbufferExternalMESA"); + return NULL; + } + + rrb = radeon_renderbuffer(rb); + image = CALLOC(sizeof *image); + if (image == NULL) + return NULL; + + image->internal_format = rb->InternalFormat; + image->format = rb->Format; + image->cpp = rrb->cpp; + image->data_type = rb->DataType; + image->data = loaderPrivate; + radeon_bo_ref(rrb->bo); + image->bo = rrb->bo; + + image->width = rb->Width; + image->height = rb->Height; + image->pitch = rrb->pitch / image->cpp; + + return image; +} + +static void +radeon_destroy_image(__DRIimage *image) +{ + radeon_bo_unref(image->bo); + FREE(image); +} + +static __DRIimage * +radeon_create_image(__DRIscreen *screen, + int width, int height, int format, + unsigned int use, + void *loaderPrivate) +{ + __DRIimage *image; + radeonScreenPtr radeonScreen = screen->private; + + image = CALLOC(sizeof *image); + if (image == NULL) + return NULL; + + switch (format) { + case __DRI_IMAGE_FORMAT_RGB565: + image->format = MESA_FORMAT_RGB565; + image->internal_format = GL_RGB; + image->data_type = GL_UNSIGNED_BYTE; + break; + case __DRI_IMAGE_FORMAT_XRGB8888: + image->format = MESA_FORMAT_XRGB8888; + image->internal_format = GL_RGB; + image->data_type = GL_UNSIGNED_BYTE; + break; + case __DRI_IMAGE_FORMAT_ARGB8888: + image->format = MESA_FORMAT_ARGB8888; + image->internal_format = GL_RGBA; + image->data_type = GL_UNSIGNED_BYTE; + break; + default: + free(image); + return NULL; + } + + image->data = loaderPrivate; + image->cpp = _mesa_get_format_bytes(image->format); + image->width = width; + image->height = height; + image->pitch = ((image->cpp * image->width + 255) & ~255) / image->cpp; + + image->bo = radeon_bo_open(radeonScreen->bom, + 0, + image->pitch * image->height * image->cpp, + 0, + RADEON_GEM_DOMAIN_VRAM, + 0); + + if (image->bo == NULL) { + FREE(image); + return NULL; + } + + return image; +} + +static GLboolean +radeon_query_image(__DRIimage *image, int attrib, int *value) +{ + switch (attrib) { + case __DRI_IMAGE_ATTRIB_STRIDE: + *value = image->pitch * image->cpp; + return GL_TRUE; + case __DRI_IMAGE_ATTRIB_HANDLE: + *value = image->bo->handle; + return GL_TRUE; + case __DRI_IMAGE_ATTRIB_NAME: + radeon_gem_get_kernel_name(image->bo, (uint32_t *) value); + return GL_TRUE; + default: + return GL_FALSE; + } +} + +static struct __DRIimageExtensionRec radeonImageExtension = { + { __DRI_IMAGE, __DRI_IMAGE_VERSION }, + radeon_create_image_from_name, + radeon_create_image_from_renderbuffer, + radeon_destroy_image, + radeon_create_image, + radeon_query_image +}; + static int radeon_set_screen_flags(radeonScreenPtr screen, int device_id) { screen->device_id = device_id; @@ -1138,6 +1322,12 @@ radeonCreateScreen( __DRIscreen *sPriv ) else screen->chip_flags |= RADEON_CLASS_R600; + /* set group bytes for r6xx+ */ + if (screen->chip_family >= CHIP_FAMILY_CEDAR) + screen->group_bytes = 512; + else + screen->group_bytes = 256; + screen->cpp = dri_priv->bpp / 8; screen->AGPMode = dri_priv->AGPMode; @@ -1382,8 +1572,13 @@ radeonCreateScreen2(__DRIscreen *sPriv) else screen->chip_flags |= RADEON_CLASS_R600; - /* r6xx+ tiling */ - if (IS_R600_CLASS(screen) && (sPriv->drm_version.minor >= 6)) { + /* r6xx+ tiling, default group bytes */ + if (screen->chip_family >= CHIP_FAMILY_CEDAR) + screen->group_bytes = 512; + else + screen->group_bytes = 256; + if (IS_R600_CLASS(screen) && (sPriv->drm_version.minor >= 6) && + (screen->chip_family < CHIP_FAMILY_CEDAR)) { ret = radeonGetParam(sPriv, RADEON_INFO_TILE_CONFIG, &temp); if (ret) fprintf(stderr, "failed to get tiling info\n"); @@ -1507,6 +1702,7 @@ radeonCreateScreen2(__DRIscreen *sPriv) #endif screen->extensions[i++] = &radeonFlushExtension.base; + screen->extensions[i++] = &radeonImageExtension.base; screen->extensions[i++] = NULL; sPriv->extensions = screen->extensions; diff --git a/src/mesa/drivers/dri/radeon/radeon_screen.h b/src/mesa/drivers/dri/radeon/radeon_screen.h index 2b33201a53..417ebf3b06 100644 --- a/src/mesa/drivers/dri/radeon/radeon_screen.h +++ b/src/mesa/drivers/dri/radeon/radeon_screen.h @@ -121,6 +121,17 @@ typedef struct radeon_screen { GLint r7xx_bank_op; } radeonScreenRec, *radeonScreenPtr; +struct __DRIimageRec { + struct radeon_bo *bo; + GLenum internal_format; + GLuint format; + GLenum data_type; + int width, height; /* in pixels */ + int pitch; /* in pixels */ + int cpp; + void *data; +}; + #define IS_R100_CLASS(screen) \ ((screen->chip_flags & RADEON_CLASS_MASK) == RADEON_CLASS_R100) #define IS_R200_CLASS(screen) \ diff --git a/src/mesa/drivers/dri/radeon/radeon_swtcl.c b/src/mesa/drivers/dri/radeon/radeon_swtcl.c index f5b0df6ef5..ff3506b225 100644 --- a/src/mesa/drivers/dri/radeon/radeon_swtcl.c +++ b/src/mesa/drivers/dri/radeon/radeon_swtcl.c @@ -412,6 +412,8 @@ static GLboolean radeon_run_render( struct gl_context *ctx, return GL_TRUE; radeon_prepare_render(&rmesa->radeon); + if (rmesa->radeon.NewGLState) + radeonValidateState( ctx ); tnl->Driver.Render.Start( ctx ); diff --git a/src/mesa/drivers/dri/radeon/radeon_tcl.c b/src/mesa/drivers/dri/radeon/radeon_tcl.c index c59b413012..5d2e8f4870 100644 --- a/src/mesa/drivers/dri/radeon/radeon_tcl.c +++ b/src/mesa/drivers/dri/radeon/radeon_tcl.c @@ -253,6 +253,8 @@ void radeonTclPrimitive( struct gl_context *ctx, GLuint newprim = hw_prim | RADEON_CP_VC_CNTL_TCL_ENABLE; radeon_prepare_render(&rmesa->radeon); + if (rmesa->radeon.NewGLState) + radeonValidateState( ctx ); if (newprim != rmesa->tcl.hw_primitive || !discrete_prim[hw_prim&0xf]) { diff --git a/src/mesa/drivers/dri/radeon/radeon_tex.c b/src/mesa/drivers/dri/radeon/radeon_tex.c index d5285e24cd..83b1d1b1d7 100644 --- a/src/mesa/drivers/dri/radeon/radeon_tex.c +++ b/src/mesa/drivers/dri/radeon/radeon_tex.c @@ -465,5 +465,9 @@ void radeonInitTextureFuncs( radeonContextPtr radeon, struct dd_function_table * functions->MapTexture = radeonMapTexture; functions->UnmapTexture = radeonUnmapTexture; +#if FEATURE_OES_EGL_image + functions->EGLImageTargetTexture2D = radeon_image_target_texture_2d; +#endif + driInitTextureFormats(); } diff --git a/src/mesa/drivers/dri/radeon/radeon_texstate.c b/src/mesa/drivers/dri/radeon/radeon_texstate.c index dd8ecdd500..32c021cb54 100644 --- a/src/mesa/drivers/dri/radeon/radeon_texstate.c +++ b/src/mesa/drivers/dri/radeon/radeon_texstate.c @@ -653,6 +653,7 @@ void radeonSetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint texture_form radeonTexObjPtr t; uint32_t pitch_val; uint32_t internalFormat, type, format; + gl_format texFormat; type = GL_BGRA; format = GL_UNSIGNED_BYTE; @@ -692,10 +693,6 @@ void radeonSetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint texture_form radeon_miptree_unreference(&t->mt); radeon_miptree_unreference(&rImage->mt); - _mesa_init_teximage_fields(radeon->glCtx, target, texImage, - rb->base.Width, rb->base.Height, 1, 0, rb->cpp); - texImage->RowStride = rb->pitch / rb->cpp; - rImage->bo = rb->bo; radeon_bo_ref(rImage->bo); t->bo = rb->bo; @@ -705,23 +702,34 @@ void radeonSetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint texture_form t->override_offset = 0; switch (rb->cpp) { case 4: - if (texture_format == __DRI_TEXTURE_FORMAT_RGB) + if (texture_format == __DRI_TEXTURE_FORMAT_RGB) { t->pp_txformat = tx_table[MESA_FORMAT_RGB888].format; - else + texFormat = MESA_FORMAT_RGB888; + } + else { t->pp_txformat = tx_table[MESA_FORMAT_ARGB8888].format; + texFormat = MESA_FORMAT_ARGB8888; + } t->pp_txfilter |= tx_table[MESA_FORMAT_ARGB8888].filter; break; case 3: default: + texFormat = MESA_FORMAT_RGB888; t->pp_txformat = tx_table[MESA_FORMAT_RGB888].format; t->pp_txfilter |= tx_table[MESA_FORMAT_RGB888].filter; break; case 2: + texFormat = MESA_FORMAT_RGB565; t->pp_txformat = tx_table[MESA_FORMAT_RGB565].format; t->pp_txfilter |= tx_table[MESA_FORMAT_RGB565].filter; break; } + _mesa_init_teximage_fields(radeon->glCtx, target, texImage, + rb->base.Width, rb->base.Height, 1, 0, + rb->cpp, texFormat); + texImage->RowStride = rb->pitch / rb->cpp; + t->pp_txpitch &= (1 << 13) -1; pitch_val = rb->pitch; diff --git a/src/mesa/drivers/dri/radeon/radeon_texture.c b/src/mesa/drivers/dri/radeon/radeon_texture.c index 18ccb512d7..8b1e34fe76 100644 --- a/src/mesa/drivers/dri/radeon/radeon_texture.c +++ b/src/mesa/drivers/dri/radeon/radeon_texture.c @@ -1007,3 +1007,67 @@ unsigned radeonIsFormatRenderable(gl_format mesa_format) return 0; } } + +#if FEATURE_OES_EGL_image +void radeon_image_target_texture_2d(struct gl_context *ctx, GLenum target, + struct gl_texture_object *texObj, + struct gl_texture_image *texImage, + GLeglImageOES image_handle) +{ + radeonContextPtr radeon = RADEON_CONTEXT(ctx); + radeonTexObj *t = radeon_tex_obj(texObj); + radeon_texture_image *radeonImage = get_radeon_texture_image(texImage); + __DRIscreen *screen; + __DRIimage *image; + + screen = radeon->dri.screen; + image = screen->dri2.image->lookupEGLImage(screen, image_handle, + screen->loaderPrivate); + if (image == NULL) + return; + + radeonFreeTexImageData(ctx, texImage); + + texImage->Width = image->width; + texImage->Height = image->height; + texImage->Depth = 1; + texImage->_BaseFormat = GL_RGBA; + texImage->TexFormat = image->format; + texImage->RowStride = image->pitch; + texImage->InternalFormat = image->internal_format; + + if(t->mt) + { + radeon_miptree_unreference(&t->mt); + t->mt = NULL; + } + + /* NOTE: The following is *very* ugly and will probably break. But + I don't know how to deal with it, without creating a whole new + function like radeon_miptree_from_bo() so I'm going with the + easy but error-prone way. */ + + radeon_try_alloc_miptree(radeon, t); + + radeonImage->mtface = _mesa_tex_target_to_face(target); + radeonImage->mtlevel = 0; + radeon_miptree_reference(t->mt, &radeonImage->mt); + + if (t->mt == NULL) + { + radeon_print(RADEON_TEXTURE, RADEON_VERBOSE, + "%s Failed to allocate miptree.\n", __func__); + return; + } + + /* Particularly ugly: this is guaranteed to break, if image->bo is + not of the required size for a miptree. */ + radeon_bo_unref(t->mt->bo); + radeon_bo_ref(image->bo); + t->mt->bo = image->bo; + + if (!radeon_miptree_matches_image(t->mt, &radeonImage->base, + radeonImage->mtface, 0)) + fprintf(stderr, "miptree doesn't match image\n"); +} +#endif diff --git a/src/mesa/drivers/dri/radeon/radeon_texture.h b/src/mesa/drivers/dri/radeon/radeon_texture.h index 9138a7d554..a1908c6bc7 100644 --- a/src/mesa/drivers/dri/radeon/radeon_texture.h +++ b/src/mesa/drivers/dri/radeon/radeon_texture.h @@ -137,4 +137,11 @@ void radeonCopyTexSubImage2D(struct gl_context *ctx, GLenum target, GLint level, unsigned radeonIsFormatRenderable(gl_format mesa_format); +#if FEATURE_OES_EGL_image +void radeon_image_target_texture_2d(struct gl_context *ctx, GLenum target, + struct gl_texture_object *texObj, + struct gl_texture_image *texImage, + GLeglImageOES image_handle); +#endif + #endif diff --git a/src/mesa/drivers/dri/savage/savage_xmesa.c b/src/mesa/drivers/dri/savage/savage_xmesa.c index b3aaa0e504..92fb4f4488 100644 --- a/src/mesa/drivers/dri/savage/savage_xmesa.c +++ b/src/mesa/drivers/dri/savage/savage_xmesa.c @@ -50,7 +50,6 @@ #include "savagespan.h" #include "savagetris.h" #include "savageioctl.h" -#include "savage_bci.h" #include "savage_dri.h" diff --git a/src/mesa/drivers/dri/swrast/swrast.c b/src/mesa/drivers/dri/swrast/swrast.c index 52ba3acf65..c7940e9c0d 100644 --- a/src/mesa/drivers/dri/swrast/swrast.c +++ b/src/mesa/drivers/dri/swrast/swrast.c @@ -48,7 +48,6 @@ #include "utils.h" #include "main/teximage.h" -#include "main/texfetch.h" #include "main/texformat.h" #include "main/texstate.h" @@ -69,6 +68,7 @@ static void swrastSetTexBuffer2(__DRIcontext *pDRICtx, GLint target, struct gl_texture_object *texObj; struct gl_texture_image *texImage; uint32_t internalFormat; + gl_format texFormat; dri_ctx = pDRICtx->driverPrivate; @@ -82,15 +82,13 @@ static void swrastSetTexBuffer2(__DRIcontext *pDRICtx, GLint target, sPriv->swrast_loader->getDrawableInfo(dPriv, &x, &y, &w, &h, dPriv->loaderPrivate); - _mesa_init_teximage_fields(&dri_ctx->Base, target, texImage, - w, h, 1, 0, internalFormat); - if (texture_format == __DRI_TEXTURE_FORMAT_RGB) - texImage->TexFormat = MESA_FORMAT_XRGB8888; + texFormat = MESA_FORMAT_XRGB8888; else - texImage->TexFormat = MESA_FORMAT_ARGB8888; + texFormat = MESA_FORMAT_ARGB8888; - _mesa_set_fetch_functions(texImage, 2); + _mesa_init_teximage_fields(&dri_ctx->Base, target, texImage, + w, h, 1, 0, internalFormat, texFormat); sPriv->swrast_loader->getImage(dPriv, x, y, w, h, (char *)texImage->Data, dPriv->loaderPrivate); diff --git a/src/mesa/drivers/dri/tdfx/tdfx_tex.c b/src/mesa/drivers/dri/tdfx/tdfx_tex.c index 0326b847cb..4cca243d07 100644 --- a/src/mesa/drivers/dri/tdfx/tdfx_tex.c +++ b/src/mesa/drivers/dri/tdfx/tdfx_tex.c @@ -698,8 +698,8 @@ convertPalette(FxU32 data[256], const struct gl_color_table *table) return GR_TEXTABLE_PALETTE_6666_EXT; default: /* XXX fixme: how can this happen? */ - _mesa_error(NULL, GL_INVALID_ENUM, "convertPalette: table->Format == %s", - _mesa_lookup_enum_by_nr(table->Format)); + _mesa_error(NULL, GL_INVALID_ENUM, "convertPalette: table->_BaseFormat == %s", + _mesa_lookup_enum_by_nr(table->_BaseFormat)); return GR_TEXTABLE_PALETTE; } } |