Previous

199869 Revisions

Next

r21576 Monday 4th March, 2013 at 23:02:36 UTC by Tafoid
Chihiro.c  [Samuele Zannoli] * Implentation of nvidia register combiners. * Fix for ide_controller_device class for most uninitialized variables.

[src/emu/machine]	idectrl.c
[src/mame/drivers]	chihiro.c

trunk/src/mame/drivers/chihiro.c

r21575	r21576
56	56	|*|Quest Of D (Ver.1.01C)                             | Sega, 2004      | CDROM  CDV-10005C |              |
57	57	|*|Sangokushi Taisen (Ver.1.002)                      | Sega, 2005      | DVDROM CDV-10009D |              |
58	58	|*|Sangokushi Taisen 2 (Ver.2.007)                    | Sega, 2006      | DVDROM CDV-10019A |              |
59		|*|Sangokushi Taisen                                  | Sega, 2005      | DVDROM CDV-10022  |              |
	59	|*|Sangokushi Taisen                                  | Sega, 2005      | DVDROM CDV-10022  |              |
60	60	|*|Sangokushi Taisen 2 Firmware Update                | Sega, 2006      | DVDROM CDV-10023  |              |
61	61	|*|Sangokushi Taisen 2                                | Sega, 2006      | DVDROM CDV-10029  |              |
62	62	|*|Sangokushi Taisen 3                                | Sega, 2008      | DVDROM CDV-10036  |              |
r21575	r21576
371	371	#include "debug/debugcon.h"
372	372	#include "debug/debugcmd.h"
373	373	#include "debug/debugcpu.h"
	374	#include "osdcore.h"
374	375
375	376	#define LOG_PCI
376		#define LOG_OHCI
	377	//#define LOG_OHCI
	378	//#define LOG_NV2A
377	379
378	380	class nv2a_renderer; // forw. dec.
379	381	struct nvidia_object_data
r21575	r21576
422	424	};
423	425
424	426	/*
425		* geforce 3d (NV2A) accelkerator
	427	* geforce 3d (NV2A) accellerator
426	428	*/
427	429	/* very simplified view
428		there is a set a set of context objects
	430	there is a set of context objects
429	431
430	432	context objects are stored in RAMIN
431	433	each context object is identified by an handle stored in RAMHT
r21575	r21576
440	442	objects have methods used to do drawing
441	443	most methods set parameters, others actually draw
442	444	*/
443		class nv2a_renderer : public poly_manager<float, nvidia_object_data, 5, 6000>
	445	class nv2a_renderer : public poly_manager<float, nvidia_object_data, 12, 6000>
444	446	{
445	447	public:
446		nv2a_renderer(running_machine &machine) : poly_manager<float, nvidia_object_data, 5, 6000>(machine)
	448	nv2a_renderer(running_machine &machine)   : poly_manager<float, nvidia_object_data, 12, 6000>(machine)
447	449	{
448	450	memset(channel,0,sizeof(channel));
449	451	memset(pfifo,0,sizeof(pfifo));
r21575	r21576
451	453	memset(pmc,0,sizeof(pmc));
452	454	memset(ramin,0,sizeof(ramin));
453	455	computedilated();
454		video_memory=(UINT32 *)machine.firstcpu->space().get_read_ptr(0xf0000000);
455	456	fb.allocate(640,480);
456	457	objectdata=&(object_data_alloc());
457	458	objectdata->data=this;
	459	combiner.used=0;
	460	combiner.lock=osd_lock_alloc();
458	461	}
459	462	DECLARE_READ32_MEMBER( geforce_r );
460	463	DECLARE_WRITE32_MEMBER( geforce_w );
461	464	void vblank_callback(screen_device &screen, bool state);
462	465	UINT32 screen_update_callback(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
463	466
464		void render_tex(INT32 scanline, const extent_t &extent, const nvidia_object_data &extradata, int threadid);
	467	void render_texture_simple(INT32 scanline, const extent_t &extent, const nvidia_object_data &extradata, int threadid);
	468	void render_color(INT32 scanline, const extent_t &extent, const nvidia_object_data &extradata, int threadid);
	469	void render_register_combiners(INT32 scanline, const extent_t &extent, const nvidia_object_data &objectdata, int threadid);
465	470
466	471	int geforce_commandkind(UINT32 word);
467	472	UINT32 geforce_object_offset(UINT32 handle);
468	473	void geforce_read_dma_object(UINT32 handle,UINT32 &offset,UINT32 &size);
469	474	void geforce_exec_method(address_space &space,UINT32 channel,UINT32 subchannel,UINT32 method,UINT32 data);
	475	void combiner_initialize_registers(UINT32 argb8[6]);
	476	void combiner_initialize_stage(int stage_number);
	477	void combiner_initialize_final();
	478	void combiner_map_input(int stage_number); // map combiner registers to variables A..D
	479	void combiner_map_output(int stage_number); // map combiner calculation results to combiner registers
	480	void combiner_map_final_input(); // map final combiner registers to variables A..F
	481	void combiner_final_output(); // generate final combiner output
	482	float combiner_map_input_select(int code,int index); // get component index in register code
	483	float *combiner_map_input_select3(int code); // get pointer to register code
	484	float *combiner_map_output_select3(int code); // get pointer to register code for output
	485	float combiner_map_input_function(int code,float value); // apply input mapping function code to value
	486	void combiner_map_input_function3(int code,float *data); // apply input mapping function code to data
	487	void combiner_function_AB(float result[4]);
	488	void combiner_function_AdotB(float result[4]);
	489	void combiner_function_CD(float result[4]);
	490	void combiner_function_CdotD(float result[4]);
	491	void combiner_function_ABmuxCD(float result[4]);
	492	void combiner_function_ABsumCD(float result[4]);
	493	void combiner_compute_rgb_outputs(int index);
	494	void combiner_compute_a_outputs(int index);
	495	void combiner_argb8_float(UINT32 color,float reg[4]);
	496	UINT32 combiner_float_argb8(float reg[4]);
470	497	UINT32 dilate0(UINT32 value,int bits);
471	498	UINT32 dilate1(UINT32 value,int bits);
472	499	void computedilated(void);
473	500	void putpixtex(int xp,int yp,int up,int vp);
	501	int toggle_register_combiners_usage();
474	502
475		UINT32 *video_memory;
476	503	struct {
477	504	UINT32 regs[0x80/4];
478	505	struct {
r21575	r21576
491	518	int sizev;
492	519	int sizew;
493	520	int dilate;
	521	int format;
494	522	void *buffer;
495		} texture;
	523	} texture[4];
	524	struct {
	525	float variable_A[4]; // 0=R 1=G 2=B 3=A
	526	float variable_B[4];
	527	float variable_C[4];
	528	float variable_D[4];
	529	float variable_E[4];
	530	float variable_F[4];
	531	float variable_G;
	532	float variable_EF[4];
	533	float variable_sumclamp[4];
	534	float function_RGBop1[4]; // 0=R 1=G 2=B
	535	float function_RGBop2[4];
	536	float function_RGBop3[4];
	537	float function_Aop1;
	538	float function_Aop2;
	539	float function_Aop3;
	540	float register_primarycolor[4]; // rw
	541	float register_secondarycolor[4];
	542	float register_texture0color[4];
	543	float register_texture1color[4];
	544	float register_texture2color[4];
	545	float register_texture3color[4];
	546	float register_color0[4];
	547	float register_color1[4];
	548	float register_spare0[4];
	549	float register_spare1[4];
	550	float register_fogcolor[4]; // ro
	551	float register_zero[4];
	552	float output[4];
	553	struct {
	554	float register_constantcolor0[4];
	555	float register_constantcolor1[4];
	556	int mapin_aA_input;
	557	int mapin_aA_component;
	558	int mapin_aA_mapping;
	559	int mapin_aB_input;
	560	int mapin_aB_component;
	561	int mapin_aB_mapping;
	562	int mapin_aC_input;
	563	int mapin_aC_component;
	564	int mapin_aC_mapping;
	565	int mapin_aD_input;
	566	int mapin_aD_component;
	567	int mapin_aD_mapping;
	568	int mapin_rgbA_input;
	569	int mapin_rgbA_component;
	570	int mapin_rgbA_mapping;
	571	int mapin_rgbB_input;
	572	int mapin_rgbB_component;
	573	int mapin_rgbB_mapping;
	574	int mapin_rgbC_input;
	575	int mapin_rgbC_component;
	576	int mapin_rgbC_mapping;
	577	int mapin_rgbD_input;
	578	int mapin_rgbD_component;
	579	int mapin_rgbD_mapping;
	580	int mapout_aCD_output;
	581	int mapout_aAB_output;
	582	int mapout_aSUM_output;
	583	int mapout_aCD_dotproduct;
	584	int mapout_aAB_dotproduct;
	585	int mapout_a_muxsum;
	586	int mapout_a_bias;
	587	int mapout_a_scale;
	588	int mapout_rgbCD_output;
	589	int mapout_rgbAB_output;
	590	int mapout_rgbSUM_output;
	591	int mapout_rgbCD_dotproduct;
	592	int mapout_rgbAB_dotproduct;
	593	int mapout_rgb_muxsum;
	594	int mapout_rgb_bias;
	595	int mapout_rgb_scale;
	596	} stage[8];
	597	struct {
	598	float register_constantcolor0[4];
	599	float register_constantcolor1[4];
	600	int color_sum_clamp;
	601	int mapin_rgbA_input;
	602	int mapin_rgbA_component;
	603	int mapin_rgbA_mapping;
	604	int mapin_rgbB_input;
	605	int mapin_rgbB_component;
	606	int mapin_rgbB_mapping;
	607	int mapin_rgbC_input;
	608	int mapin_rgbC_component;
	609	int mapin_rgbC_mapping;
	610	int mapin_rgbD_input;
	611	int mapin_rgbD_component;
	612	int mapin_rgbD_mapping;
	613	int mapin_rgbE_input;
	614	int mapin_rgbE_component;
	615	int mapin_rgbE_mapping;
	616	int mapin_rgbF_input;
	617	int mapin_rgbF_component;
	618	int mapin_rgbF_mapping;
	619	int mapin_aG_input;
	620	int mapin_aG_component;
	621	int mapin_aG_mapping;
	622	} final;
	623	int stages;
	624	int used;
	625	osd_lock *lock;
	626	} combiner;
496	627	bitmap_rgb32 fb;
497	628	UINT32 dilated0[16][2048];
498	629	UINT32 dilated1[16][2048];
r21575	r21576
844	975	}
845	976	}
846	977
	978	static void nv2a_combiners_command(running_machine &machine, int ref, int params, const char **param)
	979	{
	980	int en;
	981
	982	chihiro_state *chst=machine.driver_data<chihiro_state>();
	983	en=chst->nvidia_nv2a->toggle_register_combiners_usage();
	984	if (en != 0)
	985	debug_console_printf(machine,"Register combiners enabled\n");
	986	else
	987	debug_console_printf(machine,"Register combiners disabled\n");
	988	}
	989
847	990	static void help_command(running_machine &machine, int ref, int params, const char **param)
848	991	{
849	992	debug_console_printf(machine,"Available Chihiro commands:\n");
r21575	r21576
851	994	debug_console_printf(machine,"  chihiro dump_string,<address> -- Dump _STRING object at <address>\n");
852	995	debug_console_printf(machine,"  chihiro dump_process,<address> -- Dump _PROCESS object at <address>\n");
853	996	debug_console_printf(machine,"  chihiro dump_list,<address>[,<offset>] -- Dump _LIST_ENTRY chain starting at <address>\n");
	997	debug_console_printf(machine,"  chihiro nv2a_combiners -- Toggle use of register combiners\n");
854	998	debug_console_printf(machine,"  chihiro help -- this list\n");
855	999	}
856	1000
r21575	r21576
866	1010	dump_process_command(machine,ref,params-1,param+1);
867	1011	else if (strcmp("dump_list",param[0]) == 0)
868	1012	dump_list_command(machine,ref,params-1,param+1);
	1013	else if (strcmp("nv2a_combiners",param[0]) == 0)
	1014	nv2a_combiners_command(machine,ref,params-1,param+1);
869	1015	else
870	1016	help_command(machine,ref,params-1,param+1);
871	1017	}
r21575	r21576
949	1095	}
950	1096	}*/
951	1097
952		void nv2a_renderer::render_tex(INT32 scanline, const extent_t &extent, const nvidia_object_data &objectdata, int threadid)
	1098	void nv2a_renderer::render_color(INT32 scanline, const extent_t &extent, const nvidia_object_data &objectdata, int threadid)
953	1099	{
954	1100	int x;
955	1101
	1102	x=extent.stopx-extent.startx; // number of pixels to draw
	1103	while (x >= 0) {
	1104	UINT32 a8r8g8b8;
	1105	int ca,cr,cg,cb;
	1106	int xp=extent.startx+x; // x coordinate of current pixel
	1107
	1108	cb=(extent.param[0].start+(float)x*extent.param[0].dpdx);
	1109	cg=(extent.param[1].start+(float)x*extent.param[1].dpdx);
	1110	cr=(extent.param[2].start+(float)x*extent.param[2].dpdx);
	1111	ca=(extent.param[3].start+(float)x*extent.param[3].dpdx);
	1112	a8r8g8b8=(ca << 24)+(cr << 16)+(cg << 8)+cb; // pixel color obtained by interpolating the colors of the vertices
	1113	*((UINT32 *)objectdata.data->fb.raw_pixptr(scanline,xp))=a8r8g8b8;
	1114	x--;
	1115	}
	1116	}
	1117
	1118	UINT32 convert_a4r4g4b4_a8r8g8b8(UINT32 a4r4g4b4)
	1119	{
	1120	UINT32 a8r8g8b8;
	1121	int ca,cr,cg,cb;
	1122
	1123	cb=(a4r4g4b4 & 0xf)*17; // ((a4r4g4b4 & 0xf)*255)/15
	1124	cg=((a4r4g4b4 & 0xf0)*816)/3; // (((a4r4g4b4 & 0xf0) >> 4)*255)/15) << 8
	1125	cr=(a4r4g4b4 & 0xf00)*17*256; // (((a4r4g4b4 & 0xf00) >> 8)*255)/15) << 16
	1126	ca=(a4r4g4b4 & 0xf000)*4096*17; //((a4r4g4b4 & 0xf000) >> 12)*255/15 << 24
	1127	a8r8g8b8=ca+cb+cg+cr; // color converted to 8 bits per component
	1128	return a8r8g8b8;
	1129	}
	1130
	1131	void nv2a_renderer::render_texture_simple(INT32 scanline, const extent_t &extent, const nvidia_object_data &objectdata, int threadid)
	1132	{
	1133	int x;
	1134
	1135	if (!objectdata.data->texture[0].enabled) {
	1136	return;
	1137	}
956	1138	x=extent.stopx-extent.startx;
957	1139	while (x >= 0) {
958	1140	int to;
959		UINT32 a8r8g8b8,a4r4g4b4;
	1141	UINT32 a4r4g4b4;
960	1142	int up,vp;
961		int xp=extent.startx+x;
962		if (objectdata.data->texture.enabled) {
963		up=(extent.param[3].start+(float)x*extent.param[3].dpdx)*(float)(objectdata.data->texture.sizeu-1);
964		vp=extent.param[4].start*(float)(objectdata.data->texture.sizev-1);
965		to=(objectdata.data->dilated0[objectdata.data->texture.dilate][up]+objectdata.data->dilated1[objectdata.data->texture.dilate][vp]);
966		a4r4g4b4=*(((UINT16 *)objectdata.data->texture.buffer)+to);
967		a8r8g8b8=((a4r4g4b4 & 0xf) << 4)+((a4r4g4b4 & 0xf0) << 8)+((a4r4g4b4 & 0xf00) << 12);
968		*((UINT32 *)objectdata.data->fb.raw_pixptr(scanline,xp))=a8r8g8b8;
969		} else {
	1143	int xp=extent.startx+x; // x coordinate of current pixel
	1144
	1145	up=(extent.param[4].start+(float)x*extent.param[4].dpdx)*(float)(objectdata.data->texture[0].sizeu-1); // x coordinate of texel in texture
	1146	vp=extent.param[5].start*(float)(objectdata.data->texture[0].sizev-1); // y coordinate of texel in texture
	1147	to=(objectdata.data->dilated0[objectdata.data->texture[0].dilate][up]+objectdata.data->dilated1[objectdata.data->texture[0].dilate][vp]); // offset of texel in texture memory
	1148	a4r4g4b4=*(((UINT16 *)objectdata.data->texture[0].buffer)+to); // get texel color
	1149	*((UINT32 *)objectdata.data->fb.raw_pixptr(scanline,xp))=convert_a4r4g4b4_a8r8g8b8(a4r4g4b4);
	1150	x--;
	1151	}
	1152	}
	1153
	1154	void nv2a_renderer::render_register_combiners(INT32 scanline, const extent_t &extent, const nvidia_object_data &objectdata, int threadid)
	1155	{
	1156	int x,xp;
	1157	int to;
	1158	int up,vp;
	1159	int ca,cr,cg,cb;
	1160	UINT32 color[6];
	1161	UINT32 a8r8g8b8;
	1162	int n;//,m,i,j,k;
	1163
	1164	osd_lock_acquire(combiner.lock); // needed since multithreading is not supported yet
	1165	x=extent.stopx-extent.startx; // number of pixels to draw
	1166	while (x >= 0) {
	1167	xp=extent.startx+x;
	1168	// 1: fetch data
	1169	// 1.1: interpolated color from vertices
	1170	cb=(extent.param[0].start+(float)x*extent.param[0].dpdx);
	1171	cg=(extent.param[1].start+(float)x*extent.param[1].dpdx);
	1172	cr=(extent.param[2].start+(float)x*extent.param[2].dpdx);
	1173	ca=(extent.param[3].start+(float)x*extent.param[3].dpdx);
	1174	color[0]=(ca << 24)+(cr << 16)+(cg << 8)+cb; // pixel color obtained by interpolating the colors of the vertices
	1175	color[1]=0; // lighting not yet
	1176	// 1.2: color for each of the 4 possible textures
	1177	for (n=0;n < 4;n++) {
	1178	if (texture[n].enabled) {
	1179	up=(extent.param[4+n*2].start+(float)x*extent.param[4+n*2].dpdx)*(float)(objectdata.data->texture[n].sizeu-1);
	1180	vp=extent.param[5+n*2].start*(float)(objectdata.data->texture[n].sizev-1);
	1181	to=(objectdata.data->dilated0[objectdata.data->texture[n].dilate][up]+objectdata.data->dilated1[objectdata.data->texture[n].dilate][vp]);
	1182	color[n+2]=*(((UINT16 *)objectdata.data->texture[n].buffer)+to);
	1183	color[n+2]=convert_a4r4g4b4_a8r8g8b8(color[n+2]);
	1184	}
970	1185	}
	1186	// 2: compute
	1187	// 2.1: initialize
	1188	combiner_initialize_registers(color);
	1189	// 2.2: general cmbiner stages
	1190	for (n=0;n < combiner.stages;n++) {
	1191	// 2.2.1 initialize
	1192	combiner_initialize_stage(n);
	1193	// 2.2.2 map inputs
	1194	combiner_map_input(n);
	1195	// 2.2.3 compute possible outputs
	1196	combiner_compute_rgb_outputs(n);
	1197	combiner_compute_a_outputs(n);
	1198	// 2.2.4 map outputs to registers
	1199	combiner_map_output(n);
	1200	}
	1201	// 2.3: final cmbiner stage
	1202	combiner_initialize_final();
	1203	combiner_map_final_input();
	1204	combiner_final_output();
	1205	a8r8g8b8=combiner_float_argb8(combiner.output);
	1206	// 3: write pixel
	1207	*((UINT32 *)objectdata.data->fb.raw_pixptr(scanline,xp))=a8r8g8b8;
971	1208	x--;
	1209	}
	1210	osd_lock_release(combiner.lock);
	1211	}
	1212
	1213	#if 0
	1214	const char *rc_mapping_str[]={
	1215	"UNSIGNED_IDENTITY",
	1216	"UNSIGNED_INVERT",
	1217	"EXPAND_NORMAL",
	1218	"EXPAND_NEGATE",
	1219	"HALF_BIAS_NORMAL",
	1220	"HALF_BIAS_NEGATE",
	1221	"SIGNED_IDENTITY",
	1222	"SIGNED_NEGATE"
	1223	};
	1224
	1225	const char *rc_usage_rgb_str[]={
	1226	"RGB",
	1227	"ALPHA"
	1228	};
	1229
	1230	const char *rc_usage_alpha_str[]={
	1231	"BLUE",
	1232	"ALPHA"
	1233	};
	1234
	1235	const char *rc_variable_str[]={
	1236	"ZERO",
	1237	"CONSTANT_COLOR0",
	1238	"CONSTANT_COLOR1",
	1239	"FOG",
	1240	"PRIMARY_COLOR",
	1241	"SECONDARY_COLOR",
	1242	"???",
	1243	"???",
	1244	"TEXTURE0",
	1245	"TEXTURE1",
	1246	"TEXTURE2",
	1247	"TEXTURE3",
	1248	"SPARE0",
	1249	"SPARE1",
	1250	"SPARE0_PLUS_SECONDARY_COLOR",
	1251	"E_TIMES_F"
	1252	};
	1253
	1254	const char *rc_bias_str[]={
	1255	"NONE",
	1256	"BIAS_BY_NEGATIVE_ONE_HALF"
	1257	};
	1258
	1259	const char *rc_scale_str[]={
	1260	"NONE",
	1261	"SCALE_BY_TWO",
	1262	"SCALE_BY_FOUR",
	1263	"SCALE_BY_ONE_HALF"
	1264	};
	1265
	1266	/* Dump the current setup of the register combiners */
	1267	void dumpcombiners(UINT32 *m)
	1268	{
	1269	int a,b,n,v;
	1270
	1271	n=m[0x1e60/4] & 0xf;
	1272	printf("Combiners active: %d\n\r",n);
	1273	for (a=0;a < n;a++) {
	1274	printf("Combiner %d\n\r",a+1);
	1275	printf(" RC_IN_ALPHA %08X\n\r",m[0x0260/4+a]);
	1276	for (b=24;b >= 0;b=b-8) {
	1277	v=(m[0x0260/4+a] >> b) & 0xf;
	1278	printf("  %c_INPUT %s\n\r",'A'+3-b/8,rc_variable_str[v]);
	1279	v=(m[0x0260/4+a] >> (b+4)) & 1;
	1280	printf("  %c_COMPONENT_USAGE %s\n\r",'A'+3-b/8,rc_usage_alpha_str[v]);
	1281	v=(m[0x0260/4+a] >> (b+5)) & 7;
	1282	printf("  %c_MAPPING %s\n\r",'A'+3-b/8,rc_mapping_str[v]);
	1283	}
	1284	printf(" RC_IN_RGB %08X\n\r",m[0x0ac0/4+a]);
	1285	for (b=24;b >= 0;b=b-8) {
	1286	v=(m[0x0ac0/4+a] >> b) & 0xf;
	1287	printf("  %c_INPUT %s\n\r",'A'+3-b/8,rc_variable_str[v]);
	1288	v=(m[0x0ac0/4+a] >> (b+4)) & 1;
	1289	printf("  %c_COMPONENT_USAGE %s\n\r",'A'+3-b/8,rc_usage_rgb_str[v]);
	1290	v=(m[0x0ac0/4+a] >> (b+5)) & 7;
	1291	printf("  %c_MAPPING %s\n\r",'A'+3-b/8,rc_mapping_str[v]);
	1292	}
	1293	printf(" RC_OUT_ALPHA %08X\n\r",m[0x0aa0/4+a]);
	1294	v=m[0x0aa0/4+a] & 0xf;
	1295	printf("  CD_OUTPUT %s\n\r",rc_variable_str[v]);
	1296	v=(m[0x0aa0/4+a] >> 4) & 0xf;
	1297	printf("  AB_OUTPUT %s\n\r",rc_variable_str[v]);
	1298	v=(m[0x0aa0/4+a] >> 8) & 0xf;
	1299	printf("  SUM_OUTPUT %s\n\r",rc_variable_str[v]);
	1300	v=(m[0x0aa0/4+a] >> 12) & 1;
	1301	printf("  CD_DOT_PRODUCT %d\n\r",v);
	1302	v=(m[0x0aa0/4+a] >> 13) & 1;
	1303	printf("  AB_DOT_PRODUCT %d\n\r",v);
	1304	v=(m[0x0aa0/4+a] >> 14) & 1;
	1305	printf("  MUX_SUM %d\n\r",v);
	1306	v=(m[0x0aa0/4+a] >> 15) & 1;
	1307	printf("  BIAS %s\n\r",rc_bias_str[v]);
	1308	v=(m[0x0aa0/4+a] >> 16) & 3;
	1309	printf("  SCALE %s\n\r",rc_scale_str[v]);
	1310	//v=(m[0x0aa0/4+a] >> 27) & 7;
	1311	printf(" RC_OUT_RGB %08X\n\r",m[0x1e40/4+a]);
	1312	v=m[0x1e40/4+a] & 0xf;
	1313	printf("  CD_OUTPUT %s\n\r",rc_variable_str[v]);
	1314	v=(m[0x1e40/4+a] >> 4) & 0xf;
	1315	printf("  AB_OUTPUT %s\n\r",rc_variable_str[v]);
	1316	v=(m[0x1e40/4+a] >> 8) & 0xf;
	1317	printf("  SUM_OUTPUT %s\n\r",rc_variable_str[v]);
	1318	v=(m[0x1e40/4+a] >> 12) & 1;
	1319	printf("  CD_DOT_PRODUCT %d\n\r",v);
	1320	v=(m[0x1e40/4+a] >> 13) & 1;
	1321	printf("  AB_DOT_PRODUCT %d\n\r",v);
	1322	v=(m[0x1e40/4+a] >> 14) & 1;
	1323	printf("  MUX_SUM %d\n\r",v);
	1324	v=(m[0x1e40/4+a] >> 15) & 1;
	1325	printf("  BIAS %s\n\r",rc_bias_str[v]);
	1326	v=(m[0x1e40/4+a] >> 16) & 3;
	1327	printf("  SCALE %s\n\r",rc_scale_str[v]);
	1328	//v=(m[0x1e40/4+a] >> 27) & 7;
	1329	printf("\n\r");
972	1330	}
	1331	printf("Combiner final %08X %08X\n\r",m[0x0288/4],m[0x028c/4]);
	1332	for (a=24;a >= 0;a=a-8) {
	1333	n=(m[0x0288/4] >> a) & 0xf;
	1334	printf("  %c_INPUT %s\n\r",'A'+3-a/8,rc_variable_str[n]);
	1335	n=(m[0x0288/4] >> (a+4)) & 1;
	1336	printf("  %c_COMPONENT_USAGE %s\n\r",'A'+3-a/8,rc_usage_rgb_str[n]);
	1337	n=(m[0x0288/4] >> (a+5)) & 7;
	1338	printf("  %c_MAPPING %s\n\r",'A'+3-a/8,rc_mapping_str[n]);
	1339	}
	1340	for (a=24;a >= 8;a=a-8) {
	1341	n=(m[0x028c/4] >> a) & 0xf;
	1342	printf("  %c_INPUT %s\n\r",'E'+3-a/8,rc_variable_str[n]);
	1343	n=(m[0x028c/4] >> (a+4)) & 1;
	1344	printf("  %c_COMPONENT_USAGE %s\n\r",'E'+3-a/8,rc_usage_rgb_str[n]);
	1345	n=(m[0x028c/4] >> (a+5)) & 7;
	1346	printf("  %c_MAPPING %s\n\r",'E'+3-a/8,rc_mapping_str[n]);
	1347	}
	1348	n=(m[0x028c/4] >> 7) & 1;
	1349	printf(" color sum clamp: %d\n\r",n);
973	1350	}
	1351	#endif
974	1352
975	1353	void nv2a_renderer::geforce_exec_method(address_space & space,UINT32 chanel,UINT32 subchannel,UINT32 method,UINT32 data)
976	1354	{
	1355	UINT32 maddress=method*4;
977	1356	channel[chanel][subchannel].object.method[method]=data;
978		if ((method*4 == 0x1d6c) || (method*4 == 0x1d70) || (method*4 == 0x1a4))
	1357	if ((maddress == 0x1d6c) || (maddress == 0x1d70) || (maddress == 0x1a4))
979	1358	method=method+0;
980		if (method*4 == 0x1d70) {
	1359	if (maddress == 0x1d70) {
981	1360	// with 1d70 write the value at offest [1d6c] inside dma object [1a4]
982	1361	UINT32 offset,base;
983	1362	UINT32 dmahand,dmaoff,smasiz;
r21575	r21576
988	1367	base=dmaoff;
989	1368	space.write_dword(base+offset,data);
990	1369	}
991		if (method*4 == 0x1d94) {
	1370	if (maddress == 0x1d94) {
992	1371	// clear framebuffer
993		UINT32 color=channel[chanel][subchannel].object.method[0x1d90/4];
994		fb.fill(color & 0xffffff);
	1372	if (data & 0xf0) {
	1373	// clear colors
	1374	UINT32 color=channel[chanel][subchannel].object.method[0x1d90/4];
	1375	fb.fill(color & 0xffffff);
	1376	printf("clearscreen\n\r");
	1377	}
	1378	if (data & 0x03) {
	1379	// clear stencil+zbuffer
	1380	}
995	1381	}
996		if (method*4 == 0x1b0c) {
997		// enable texture
998		int enable;
999		//int dma0,dma1,cubic,noborder,dims,format,mipmap;
1000		int basesizeu,basesizev,basesizew;
	1382	// Texture Units
	1383	if ((maddress >= 0x1b00) && (maddress < 0x1c00)) {
	1384	int unit;//,off;
	1385
	1386	unit=(maddress >> 6) & 3;
	1387	//off=maddress & 0xc0;
	1388	maddress=maddress & ~0xc0;
	1389	if (maddress == 0x1b00) {
1001	1390	UINT32 offset;//,base;
1002	1391	//UINT32 dmahand,dmaoff,dmasiz;
1003		UINT32 tmp;
1004	1392
1005		enable=(data >> 30) & 1;
1006		offset=channel[chanel][subchannel].object.method[0x1b00/4];
1007		tmp=channel[chanel][subchannel].object.method[0x1b04/4];
1008		//dma0=(tmp >> 0) & 1;
1009		//dma1=(tmp >> 1) & 1;
1010		//cubic=(tmp >> 2) & 1;
1011		//noborder=(tmp >> 3) & 1;
1012		//dims=(tmp >> 4) & 15;
1013		//format=(tmp >> 8) & 255;
1014		//mipmap=(tmp >> 19) & 1;
1015		basesizeu=(tmp >> 20) & 15;
1016		basesizev=(tmp >> 24) & 15;
1017		basesizew=(tmp >> 28) & 15;
1018		texture.enabled=enable;
1019		texture.sizeu=1 << basesizeu;
1020		texture.sizev=1 << basesizev;
1021		texture.sizew=1 << basesizew;
1022		texture.dilate=dilatechose[(basesizeu << 4)+basesizev];
1023		texture.buffer=space.get_read_ptr(offset);
	1393	offset=data;
	1394	texture[unit].buffer=space.get_read_ptr(offset);
1024	1395	/*if (dma0 != 0) {
1025	1396	dmahand=channel[channel][subchannel].object.method[0x184/4];
1026	1397	geforce_read_dma_object(dmahand,dmaoff,smasiz);
r21575	r21576
1029	1400	geforce_read_dma_object(dmahand,dmaoff,smasiz);
1030	1401	}*/
1031	1402	}
1032		if (method*4 == 0x1810) {
	1403	if (maddress == 0x1b04) {
	1404	//int dma0,dma1,cubic,noborder,dims,mipmap;
	1405	int basesizeu,basesizev,basesizew,format;
	1406
	1407	//dma0=(data >> 0) & 1;
	1408	//dma1=(data >> 1) & 1;
	1409	//cubic=(data >> 2) & 1;
	1410	//noborder=(data >> 3) & 1;
	1411	//dims=(data >> 4) & 15;
	1412	//mipmap=(data >> 19) & 1;
	1413	format=(data >> 8) & 255;
	1414	basesizeu=(data >> 20) & 15;
	1415	basesizev=(data >> 24) & 15;
	1416	basesizew=(data >> 28) & 15;
	1417	texture[unit].sizeu=1 << basesizeu;
	1418	texture[unit].sizev=1 << basesizev;
	1419	texture[unit].sizew=1 << basesizew;
	1420	texture[unit].dilate=dilatechose[(basesizeu << 4)+basesizev];
	1421	texture[unit].format=format;
	1422	}
	1423	if (maddress == 0x1b0c) {
	1424	// enable texture
	1425	int enable;
	1426
	1427	enable=(data >> 30) & 1;
	1428	texture[unit].enabled=enable;
	1429	}
	1430	}
	1431	if (maddress == 0x1810) {
1033	1432	// draw vertices
1034	1433	int offset,count,type;
1035	1434	//int vtxbuf_kind[16],vtxbuf_size[16];
1036	1435	int vtxbuf_stride[16];
1037	1436	UINT32 vtxbuf_address[16];
1038	1437	UINT32 dmahand[2],dmaoff[2],smasiz[2];
1039		UINT32 tmp,n,m;
	1438	UINT32 tmp,n,m,u;
	1439	render_delegate renderspans;
1040	1440
1041	1441	offset=data & 0xffffff;
1042	1442	count=(data >> 24) & 0xff;
r21575	r21576
1046	1446	dmahand[1]=channel[chanel][subchannel].object.method[0x01a0/4];
1047	1447	geforce_read_dma_object(dmahand[0],dmaoff[0],smasiz[0]);
1048	1448	geforce_read_dma_object(dmahand[1],dmaoff[1],smasiz[1]);
1049		//printf("vertex %d %d %d\n\r",type,offset,count);
1050		for (n=0;n<16;n++) {
1051		//printf(" %08X %08X\n\r",channel[chanel][subchannel].object.method[0x1720/4+n],channel[chanel][subchannel].object.method[0x1760/4+n]);
	1449	if (((channel[chanel][subchannel].object.method[0x1e60/4] & 7) > 0) && (combiner.used != 0)) {
	1450	renderspans=render_delegate(FUNC(nv2a_renderer::render_register_combiners),this);
	1451	} else if (texture[0].enabled) {
	1452	renderspans=render_delegate(FUNC(nv2a_renderer::render_texture_simple),this);
	1453	} else
	1454	renderspans=render_delegate(FUNC(nv2a_renderer::render_color),this);
	1455	#ifdef LOG_NV2A
	1456	printf("vertex %d %d %d\n\r",type,offset,count);
	1457	#endif
	1458	for (n=0;n < 16;n++) {
	1459	#ifdef LOG_NV2A
	1460	printf(" %08X %08X\n\r",channel[chanel][subchannel].object.method[0x1720/4+n],channel[chanel][subchannel].object.method[0x1760/4+n]);
	1461	#endif
1052	1462	tmp=channel[chanel][subchannel].object.method[0x1760/4+n];
1053	1463	//vtxbuf_kind[n]=tmp & 15;
1054	1464	//vtxbuf_size[n]=(tmp >> 4) & 15;
r21575	r21576
1060	1470	vtxbuf_address[n]=(tmp & 0x0fffffff)+dmaoff[0];
1061	1471	}
1062	1472	if (type == nv2a_renderer::QUADS) {
	1473	#if 0
	1474	n=0;
	1475	if (n == 1)
	1476	dumpcombiners(channel[chanel][subchannel].object.method);
	1477	#endif
1063	1478	for (n=0;n <= count;n+=4) {
1064	1479	vertex_t xy[4];
1065	1480	float z[4],w[4];
1066	1481	UINT32 c[4];
1067		/*float u[4],v[4];
1068		int   xi,yi,xf,yf,dx,dy,xp,yp,up,vp;
1069		float ui,vi,uf,vf,du,dv;
1070		rectangle clip(0,0,639,479);*/
1071		render_delegate rend;
1072	1482
	1483	printf("draw quad\n\r");
1073	1484	for (m=0;m < 4;m++) {
1074	1485	*((UINT32 *)(&xy[m].x))=space.read_dword(vtxbuf_address[0]+(n+m+offset)*vtxbuf_stride[0]+0);
1075	1486	*((UINT32 *)(&xy[m].y))=space.read_dword(vtxbuf_address[0]+(n+m+offset)*vtxbuf_stride[0]+4);
1076	1487	*((UINT32 *)(&z[m]))=space.read_dword(vtxbuf_address[0]+(n+m+offset)*vtxbuf_stride[0]+8);
1077	1488	*((UINT32 *)(&w[m]))=space.read_dword(vtxbuf_address[0]+(n+m+offset)*vtxbuf_stride[0]+12);
1078	1489	c[m]=space.read_dword(vtxbuf_address[3]+(n+m+offset)*vtxbuf_stride[0]+0); // color
1079		xy[m].p[0]=c[m] & 0xff;
1080		xy[m].p[1]=(c[m] & 0xff00) >> 8;
1081		xy[m].p[2]=(c[m] & 0xff000) >> 16;
1082		if (texture.enabled) {
1083		*((UINT32 *)(&xy[m].p[3]))=space.read_dword(vtxbuf_address[9]+(n+m+offset)*vtxbuf_stride[9]+0);
1084		*((UINT32 *)(&xy[m].p[4]))=space.read_dword(vtxbuf_address[9]+(n+m+offset)*vtxbuf_stride[9]+4);
	1490	xy[m].p[0]=c[m] & 0xff; // b
	1491	xy[m].p[1]=(c[m] & 0xff00) >> 8; // g
	1492	xy[m].p[2]=(c[m] & 0xff0000) >> 16; // r
	1493	xy[m].p[3]=(c[m] & 0xff000000) >> 24; // a
	1494	for (u=0;u < 4;u++) {
	1495	xy[m].p[4+u*2]=0;
	1496	xy[m].p[5+u*2]=0;
	1497	if (texture[u].enabled) {
	1498	*((UINT32 *)(&xy[m].p[4+u*2]))=space.read_dword(vtxbuf_address[9+u]+(n+m+offset)*vtxbuf_stride[9+u]+0);
	1499	*((UINT32 *)(&xy[m].p[5+u*2]))=space.read_dword(vtxbuf_address[9+u]+(n+m+offset)*vtxbuf_stride[9+u]+4);
	1500	}
1085	1501	}
1086	1502	}
1087	1503
1088		rend=render_delegate(FUNC(nv2a_renderer::render_tex),this);
1089		render_polygon<4>(fb.cliprect(),rend,3+texture.enabled*2,xy);
	1504	render_polygon<4>(fb.cliprect(),renderspans,4+4*2,xy); // 4 rgba, 4 texture units 2 uv
1090	1505	wait();
1091	1506	/*myline(fb,xy[0].x,xy[0].y,xy[1].x,xy[1].y);
1092	1507	myline(fb,xy[1].x,xy[1].y,xy[2].x,xy[2].y);
1093	1508	myline(fb,xy[2].x,xy[2].y,xy[3].x,xy[3].y);
1094	1509	myline(fb,xy[3].x,xy[3].y,xy[0].x,xy[0].y);*/
1095		//printf(" (%f,%f,%f)-(%f,%f,%f)-(%f,%f,%f)-(%f,%f,%f)\n\r",x[0],y[0],z[0],x[1],y[1],z[1],x[2],y[2],z[2],x[3],y[3],z[3]);
	1510	#ifdef LOG_NV2A
	1511	printf(" (%f,%f,%f)-(%f,%f,%f)-(%f,%f,%f)-(%f,%f,%f)\n\r",xy[0].x,xy[0].y,z[0],xy[1].x,xy[1].y,z[1],xy[2].x,xy[2].y,z[2],xy[3].x,xy[3].y,z[3]);
	1512	#endif
1096	1513	}
	1514	} else if (type == nv2a_renderer::TRIANGLE_STRIP) {
	1515	vertex_t xy[3];
	1516	float z[3],w[3];
	1517	UINT32 c[3];
	1518
	1519	printf("draw triangle\n\r");
	1520	// put first 2 vertices data in elements 0,1 of arrays
	1521	for (m=0;m < 2;m++) {
	1522	*((UINT32 *)(&xy[m].x))=space.read_dword(vtxbuf_address[0]+(m+offset)*vtxbuf_stride[0]+0);
	1523	*((UINT32 *)(&xy[m].y))=space.read_dword(vtxbuf_address[0]+(m+offset)*vtxbuf_stride[0]+4);
	1524	*((UINT32 *)(&z[m]))=space.read_dword(vtxbuf_address[0]+(m+offset)*vtxbuf_stride[0]+8);
	1525	*((UINT32 *)(&w[m]))=space.read_dword(vtxbuf_address[0]+(m+offset)*vtxbuf_stride[0]+12);
	1526	c[m]=space.read_dword(vtxbuf_address[3]+(m+offset)*vtxbuf_stride[0]+0); // color
	1527	xy[m].p[0]=c[m] & 0xff; // b
	1528	xy[m].p[1]=(c[m] & 0xff00) >> 8;  // g
	1529	xy[m].p[2]=(c[m] & 0xff0000) >> 16;  // r
	1530	xy[m].p[3]=(c[m] & 0xff000000) >> 24;  // a
	1531	for (u=0;u < 4;u++) {
	1532	xy[m].p[4+u*2]=0;
	1533	xy[m].p[5+u*2]=0;
	1534	if (texture[u].enabled) {
	1535	*((UINT32 *)(&xy[m].p[4+u*2]))=space.read_dword(vtxbuf_address[9+u]+(m+offset)*vtxbuf_stride[9+u]+0);
	1536	*((UINT32 *)(&xy[m].p[5+u*2]))=space.read_dword(vtxbuf_address[9+u]+(m+offset)*vtxbuf_stride[9+u]+4);
	1537	}
	1538	}
	1539	}
	1540	for (n=2;n <= count;n++) {
	1541	// put vertex n data in element 2 of arrays
	1542	*((UINT32 *)(&xy[2].x))=space.read_dword(vtxbuf_address[0]+(n+offset)*vtxbuf_stride[0]+0);
	1543	*((UINT32 *)(&xy[2].y))=space.read_dword(vtxbuf_address[0]+(n+offset)*vtxbuf_stride[0]+4);
	1544	*((UINT32 *)(&z[2]))=space.read_dword(vtxbuf_address[0]+(n+offset)*vtxbuf_stride[0]+8);
	1545	*((UINT32 *)(&w[2]))=space.read_dword(vtxbuf_address[0]+(n+offset)*vtxbuf_stride[0]+12);
	1546	c[2]=space.read_dword(vtxbuf_address[3]+(n+offset)*vtxbuf_stride[0]+0); // color
	1547	xy[2].p[0]=c[2] & 0xff; // b
	1548	xy[2].p[1]=(c[2] & 0xff00) >> 8; // g
	1549	xy[2].p[2]=(c[2] & 0xff0000) >> 16; // r
	1550	xy[2].p[3]=(c[2] & 0xff000000) >> 24; // a
	1551	for (u=0;u < 4;u++) {
	1552	xy[2].p[4+u*2]=0;
	1553	xy[2].p[5+u*2]=0;
	1554	if (texture[u].enabled) {
	1555	*((UINT32 *)(&xy[2].p[4+u*2]))=space.read_dword(vtxbuf_address[9+u]+(n+offset)*vtxbuf_stride[9+u]+0);
	1556	*((UINT32 *)(&xy[2].p[5+u*2]))=space.read_dword(vtxbuf_address[9+u]+(n+offset)*vtxbuf_stride[9+u]+4);
	1557	}
	1558	}
	1559	// draw triangle
	1560	render_triangle(fb.cliprect(),renderspans,4+4*2,xy[n & 1],xy[~n & 1],xy[2]); // 012,102,012,102...
	1561	wait();
	1562	// move elements 1,2 to 0,1
	1563	xy[0]=xy[1];
	1564	xy[1]=xy[2];
	1565	z[0]=z[1];
	1566	z[1]=z[2];
	1567	w[0]=w[1];
	1568	w[1]=w[2];
	1569	}
1097	1570	} else {
1098		type=type+0;
	1571	type=type+0; // dummy, you can put a breakpoint here while debugging
1099	1572	}
1100	1573	}
	1574	if (maddress == 0x1e60)
	1575	combiner.stages=data & 15;
	1576	if (maddress == 0x0288) {
	1577	combiner.final.mapin_rgbD_input=data & 15;
	1578	combiner.final.mapin_rgbD_component=(data >> 4) & 1;
	1579	combiner.final.mapin_rgbD_mapping=(data >> 5) & 7;
	1580	combiner.final.mapin_rgbC_input=(data >> 8) & 15;
	1581	combiner.final.mapin_rgbC_component=(data >> 12) & 1;
	1582	combiner.final.mapin_rgbC_mapping=(data >> 13) & 7;
	1583	combiner.final.mapin_rgbB_input=(data >> 16) & 15;
	1584	combiner.final.mapin_rgbB_component=(data >> 20) & 1;
	1585	combiner.final.mapin_rgbB_mapping=(data >> 21) & 7;
	1586	combiner.final.mapin_rgbA_input=(data >> 24) & 15;
	1587	combiner.final.mapin_rgbA_component=(data >> 28) & 1;
	1588	combiner.final.mapin_rgbA_mapping=(data >> 29) & 7;
	1589	}
	1590	if (maddress == 0x028c) {
	1591	combiner.final.color_sum_clamp=(data >> 7) & 1;
	1592	combiner.final.mapin_aG_input=(data >> 8) & 15;
	1593	combiner.final.mapin_aG_component=(data >> 12) & 1;
	1594	combiner.final.mapin_aG_mapping=(data >> 13) & 7;
	1595	combiner.final.mapin_rgbF_input=(data >> 16) & 15;
	1596	combiner.final.mapin_rgbF_component=(data >> 20) & 1;
	1597	combiner.final.mapin_rgbF_mapping=(data >> 21) & 7;
	1598	combiner.final.mapin_rgbE_input=(data >> 24) & 15;
	1599	combiner.final.mapin_rgbE_component=(data >> 28) & 1;
	1600	combiner.final.mapin_rgbE_mapping=(data >> 29) & 7;
	1601	}
	1602	if (maddress == 0x1e20) {
	1603	combiner_argb8_float(data,combiner.final.register_constantcolor0);
	1604	}
	1605	if (maddress == 0x1e24) {
	1606	combiner_argb8_float(data,combiner.final.register_constantcolor1);
	1607	}
	1608	if ((maddress >= 0x0260) && (maddress < 0x0280)) {
	1609	int n;
	1610
	1611	n=(maddress-0x0260) >> 2;
	1612	combiner.stage[n].mapin_aD_input=data & 15;
	1613	combiner.stage[n].mapin_aD_component=(data >> 4) & 1;
	1614	combiner.stage[n].mapin_aD_mapping=(data >> 5) & 7;
	1615	combiner.stage[n].mapin_aC_input=(data >> 8) & 15;
	1616	combiner.stage[n].mapin_aC_component=(data >> 12) & 1;
	1617	combiner.stage[n].mapin_aC_mapping=(data >> 13) & 7;
	1618	combiner.stage[n].mapin_aB_input=(data >> 16) & 15;
	1619	combiner.stage[n].mapin_aB_component=(data >> 20) & 1;
	1620	combiner.stage[n].mapin_aB_mapping=(data >> 21) & 7;
	1621	combiner.stage[n].mapin_aA_input=(data >> 24) & 15;
	1622	combiner.stage[n].mapin_aA_component=(data >> 28) & 1;
	1623	combiner.stage[n].mapin_aA_mapping=(data >> 29) & 7;
	1624	}
	1625	if ((maddress >= 0x0ac0) && (maddress < 0x0ae0)) {
	1626	int n;
	1627
	1628	n=(maddress-0x0ac0) >> 2;
	1629	combiner.stage[n].mapin_rgbD_input=data & 15;
	1630	combiner.stage[n].mapin_rgbD_component=(data >> 4) & 1;
	1631	combiner.stage[n].mapin_rgbD_mapping=(data >> 5) & 7;
	1632	combiner.stage[n].mapin_rgbC_input=(data >> 8) & 15;
	1633	combiner.stage[n].mapin_rgbC_component=(data >> 12) & 1;
	1634	combiner.stage[n].mapin_rgbC_mapping=(data >> 13) & 7;
	1635	combiner.stage[n].mapin_rgbB_input=(data >> 16) & 15;
	1636	combiner.stage[n].mapin_rgbB_component=(data >> 20) & 1;
	1637	combiner.stage[n].mapin_rgbB_mapping=(data >> 21) & 7;
	1638	combiner.stage[n].mapin_rgbA_input=(data >> 24) & 15;
	1639	combiner.stage[n].mapin_rgbA_component=(data >> 28) & 1;
	1640	combiner.stage[n].mapin_rgbA_mapping=(data >> 29) & 7;
	1641	}
	1642	if ((maddress >= 0x0a60) && (maddress < 0x0a80)) {
	1643	int n;
	1644
	1645	n=(maddress-0x0a60) >> 2;
	1646	combiner_argb8_float(data,combiner.stage[n].register_constantcolor0);
	1647	}
	1648	if ((maddress >= 0x0a80) && (maddress < 0x0aa0)) {
	1649	int n;
	1650
	1651	n=(maddress-0x0a80) >> 2;
	1652	combiner_argb8_float(data,combiner.stage[n].register_constantcolor1);
	1653	}
	1654	if ((maddress >= 0x0aa0) && (maddress < 0x0ac0)) {
	1655	int n;
	1656
	1657	n=(maddress-0x0aa0) >> 2;
	1658	combiner.stage[n].mapout_aCD_output=data & 15;
	1659	combiner.stage[n].mapout_aAB_output=(data >> 4) & 15;
	1660	combiner.stage[n].mapout_aSUM_output=(data >> 8) & 15;
	1661	combiner.stage[n].mapout_aCD_dotproduct=(data >> 12) & 1;
	1662	combiner.stage[n].mapout_aAB_dotproduct=(data >> 13) & 1;
	1663	combiner.stage[n].mapout_a_muxsum=(data >> 14) & 1;
	1664	combiner.stage[n].mapout_a_bias=(data >> 15) & 1;
	1665	combiner.stage[n].mapout_a_scale=(data >> 16) & 3;
	1666	//combiner.=(data >> 27) & 7;
	1667	}
	1668	if ((maddress >= 0x1e40) && (maddress < 0x1e60)) {
	1669	int n;
	1670
	1671	n=(maddress-0x1e40) >> 2;
	1672	combiner.stage[n].mapout_rgbCD_output=data & 15;
	1673	combiner.stage[n].mapout_rgbAB_output=(data >> 4) & 15;
	1674	combiner.stage[n].mapout_rgbSUM_output=(data >> 8) & 15;
	1675	combiner.stage[n].mapout_rgbCD_dotproduct=(data >> 12) & 1;
	1676	combiner.stage[n].mapout_rgbAB_dotproduct=(data >> 13) & 1;
	1677	combiner.stage[n].mapout_rgb_muxsum=(data >> 14) & 1;
	1678	combiner.stage[n].mapout_rgb_bias=(data >> 15) & 1;
	1679	combiner.stage[n].mapout_rgb_scale=(data >> 16) & 3;
	1680	//combiner.=(data >> 27) & 7;
	1681	}
1101	1682	}
1102	1683
	1684	int nv2a_renderer::toggle_register_combiners_usage()
	1685	{
	1686	combiner.used=1-combiner.used;
	1687	return combiner.used;
	1688	}
	1689
	1690	void nv2a_renderer::combiner_argb8_float(UINT32 color,float reg[4])
	1691	{
	1692	reg[0]=(float)(color & 0xff)/255.0;
	1693	reg[1]=(float)((color >> 8) & 0xff)/255.0;
	1694	reg[2]=(float)((color >> 16) & 0xff)/255.0;
	1695	reg[3]=(float)((color >> 24) & 0xff)/255.0;
	1696	}
	1697
	1698	UINT32 nv2a_renderer::combiner_float_argb8(float reg[4])
	1699	{
	1700	UINT32 r,g,b,a;
	1701
	1702	a=reg[3]*255.0;
	1703	b=reg[2]*255.0;
	1704	g=reg[1]*255.0;
	1705	r=reg[0]*255.0;
	1706	return (a << 24) | (r << 16) | (g << 8) | b;
	1707	}
	1708
	1709	float nv2a_renderer::combiner_map_input_select(int code,int index)
	1710	{
	1711	switch (code) {
	1712	case 0:
	1713	default:
	1714	return combiner.register_zero[index];
	1715	break;
	1716	case 1:
	1717	return combiner.register_color0[index];
	1718	break;
	1719	case 2:
	1720	return combiner.register_color1[index];
	1721	break;
	1722	case 3:
	1723	return combiner.register_fogcolor[index];
	1724	break;
	1725	case 4:
	1726	return combiner.register_primarycolor[index];
	1727	break;
	1728	case 5:
	1729	return combiner.register_secondarycolor[index];
	1730	break;
	1731	case 8:
	1732	return combiner.register_texture0color[index];
	1733	break;
	1734	case 9:
	1735	return combiner.register_texture1color[index];
	1736	break;
	1737	case 10:
	1738	return combiner.register_texture2color[index];
	1739	break;
	1740	case 11:
	1741	return combiner.register_texture3color[index];
	1742	break;
	1743	case 12:
	1744	return combiner.register_spare0[index];
	1745	break;
	1746	case 13:
	1747	return combiner.register_spare1[index];
	1748	break;
	1749	case 14:
	1750	return combiner.variable_sumclamp[index];
	1751	break;
	1752	case 15:
	1753	return combiner.variable_EF[index];
	1754	break;
	1755	}
	1756	}
	1757
	1758	float *nv2a_renderer::combiner_map_input_select3(int code)
	1759	{
	1760	switch (code) {
	1761	case 0:
	1762	default:
	1763	return combiner.register_zero;
	1764	break;
	1765	case 1:
	1766	return combiner.register_color0;
	1767	break;
	1768	case 2:
	1769	return combiner.register_color1;
	1770	break;
	1771	case 3:
	1772	return combiner.register_fogcolor;
	1773	break;
	1774	case 4:
	1775	return combiner.register_primarycolor;
	1776	break;
	1777	case 5:
	1778	return combiner.register_secondarycolor;
	1779	break;
	1780	case 8:
	1781	return combiner.register_texture0color;
	1782	break;
	1783	case 9:
	1784	return combiner.register_texture1color;
	1785	break;
	1786	case 10:
	1787	return combiner.register_texture2color;
	1788	break;
	1789	case 11:
	1790	return combiner.register_texture3color;
	1791	break;
	1792	case 12:
	1793	return combiner.register_spare0;
	1794	break;
	1795	case 13:
	1796	return combiner.register_spare1;
	1797	break;
	1798	case 14:
	1799	return combiner.variable_sumclamp;
	1800	break;
	1801	case 15:
	1802	return combiner.variable_EF;
	1803	break;
	1804	}
	1805	}
	1806
	1807	float *nv2a_renderer::combiner_map_output_select3(int code)
	1808	{
	1809	switch (code) {
	1810	case 0:
	1811	return 0;
	1812	break;
	1813	case 1:
	1814	return 0;
	1815	break;
	1816	case 2:
	1817	return 0;
	1818	break;
	1819	case 3:
	1820	return 0;
	1821	break;
	1822	case 4:
	1823	return combiner.register_primarycolor;
	1824	break;
	1825	case 5:
	1826	return combiner.register_secondarycolor;
	1827	break;
	1828	case 8:
	1829	return combiner.register_texture0color;
	1830	break;
	1831	case 9:
	1832	return combiner.register_texture1color;
	1833	break;
	1834	case 10:
	1835	return combiner.register_texture2color;
	1836	break;
	1837	case 11:
	1838	return combiner.register_texture3color;
	1839	break;
	1840	case 12:
	1841	return combiner.register_spare0;
	1842	break;
	1843	case 13:
	1844	return combiner.register_spare1;
	1845	break;
	1846	case 14:
	1847	return 0;
	1848	break;
	1849	case 15:
	1850	default:
	1851	return 0;
	1852	break;
	1853	}
	1854	}
	1855
	1856	float nv2a_renderer::combiner_map_input_function(int code,float value)
	1857	{
	1858	float t;
	1859
	1860	switch (code) {
	1861	case 0:
	1862	return MAX(0.0,value);
	1863	break;
	1864	case 1:
	1865	t=MAX(value, 0.0);
	1866	return 1.0 - MIN(t, 1.0);
	1867	break;
	1868	case 2:
	1869	return 2.0 * MAX(0.0, value) - 1.0;
	1870	break;
	1871	case 3:
	1872	return -2.0 * MAX(0.0, value) + 1.0;
	1873	break;
	1874	case 4:
	1875	return MAX(0.0, value) - 0.5;
	1876	break;
	1877	case 5:
	1878	return -MAX(0.0, value) + 0.5;
	1879	break;
	1880	case 6:
	1881	return value;
	1882	break;
	1883	case 7:
	1884	default:
	1885	return -value;
	1886	break;
	1887	}
	1888	}
	1889
	1890	void nv2a_renderer::combiner_map_input_function3(int code,float *data)
	1891	{
	1892	float t;
	1893
	1894	switch (code) {
	1895	case 0:
	1896	data[0]=MAX(0.0,data[0]);
	1897	data[1]=MAX(0.0,data[1]);
	1898	data[2]=MAX(0.0,data[2]);
	1899	break;
	1900	case 1:
	1901	t=MAX(data[0], 0.0);
	1902	data[0]=1.0 - MIN(t, 1.0);
	1903	t=MAX(data[1], 0.0);
	1904	data[1]=1.0 - MIN(t, 1.0);
	1905	t=MAX(data[2], 0.0);
	1906	data[2]=1.0 - MIN(t, 1.0);
	1907	break;
	1908	case 2:
	1909	data[0]=2.0 * MAX(0.0, data[0]) - 1.0;
	1910	data[1]=2.0 * MAX(0.0, data[1]) - 1.0;
	1911	data[2]=2.0 * MAX(0.0, data[2]) - 1.0;
	1912	break;
	1913	case 3:
	1914	data[0]=-2.0 * MAX(0.0, data[0]) + 1.0;
	1915	data[1]=-2.0 * MAX(0.0, data[1]) + 1.0;
	1916	data[2]=-2.0 * MAX(0.0, data[2]) + 1.0;
	1917	break;
	1918	case 4:
	1919	data[0]=MAX(0.0, data[0]) - 0.5;
	1920	data[1]=MAX(0.0, data[1]) - 0.5;
	1921	data[2]=MAX(0.0, data[2]) - 0.5;
	1922	break;
	1923	case 5:
	1924	data[0]=-MAX(0.0, data[0]) + 0.5;
	1925	data[1]=-MAX(0.0, data[1]) + 0.5;
	1926	data[2]=-MAX(0.0, data[2]) + 0.5;
	1927	break;
	1928	case 6:
	1929	return;
	1930	break;
	1931	case 7:
	1932	default:
	1933	data[0]=-data[0];
	1934	data[1]=-data[1];
	1935	data[2]=-data[2];
	1936	break;
	1937	}
	1938	}
	1939
	1940	void nv2a_renderer::combiner_initialize_registers(UINT32 argb8[6])
	1941	{
	1942	combiner_argb8_float(argb8[0],combiner.register_primarycolor);
	1943	combiner_argb8_float(argb8[1],combiner.register_secondarycolor);
	1944	combiner_argb8_float(argb8[2],combiner.register_texture0color);
	1945	combiner_argb8_float(argb8[3],combiner.register_texture1color);
	1946	combiner_argb8_float(argb8[4],combiner.register_texture2color);
	1947	combiner_argb8_float(argb8[5],combiner.register_texture3color);
	1948	combiner.register_spare0[3]=combiner.register_texture0color[3];
	1949	combiner.register_zero[0]=combiner.register_zero[1]=combiner.register_zero[2]=combiner.register_zero[3]=0;
	1950	}
	1951
	1952	void nv2a_renderer::combiner_initialize_stage(int stage_number)
	1953	{
	1954	int n=stage_number;
	1955
	1956	// put register_constantcolor0 in register_color0
	1957	combiner.register_color0[0]=combiner.stage[n].register_constantcolor0[0];
	1958	combiner.register_color0[1]=combiner.stage[n].register_constantcolor0[1];
	1959	combiner.register_color0[2]=combiner.stage[n].register_constantcolor0[2];
	1960	combiner.register_color0[3]=combiner.stage[n].register_constantcolor0[3];
	1961	// put register_constantcolor1 in register_color1
	1962	combiner.register_color1[0]=combiner.stage[n].register_constantcolor1[0];
	1963	combiner.register_color1[1]=combiner.stage[n].register_constantcolor1[1];
	1964	combiner.register_color1[2]=combiner.stage[n].register_constantcolor1[2];
	1965	combiner.register_color1[3]=combiner.stage[n].register_constantcolor1[3];
	1966	}
	1967
	1968	void nv2a_renderer::combiner_initialize_final()
	1969	{
	1970	// put register_constantcolor0 in register_color0
	1971	combiner.register_color0[0]=combiner.final.register_constantcolor0[0];
	1972	combiner.register_color0[1]=combiner.final.register_constantcolor0[1];
	1973	combiner.register_color0[2]=combiner.final.register_constantcolor0[2];
	1974	combiner.register_color0[3]=combiner.final.register_constantcolor0[3];
	1975	// put register_constantcolor1 in register_color1
	1976	combiner.register_color1[0]=combiner.final.register_constantcolor1[0];
	1977	combiner.register_color1[1]=combiner.final.register_constantcolor1[1];
	1978	combiner.register_color1[2]=combiner.final.register_constantcolor1[2];
	1979	combiner.register_color1[3]=combiner.final.register_constantcolor1[3];
	1980	}
	1981
	1982	void nv2a_renderer::combiner_map_input(int stage_number)
	1983	{
	1984	int n=stage_number;
	1985	int c,d,i;
	1986	float v,*pv;
	1987
	1988	// A
	1989	v=combiner_map_input_select(combiner.stage[n].mapin_aA_input,2+combiner.stage[n].mapin_aA_component);
	1990	combiner.variable_A[3]=combiner_map_input_function(combiner.stage[n].mapin_aA_mapping,v);
	1991	// B
	1992	v=combiner_map_input_select(combiner.stage[n].mapin_aB_input,2+combiner.stage[n].mapin_aB_component);
	1993	combiner.variable_B[3]=combiner_map_input_function(combiner.stage[n].mapin_aB_mapping,v);
	1994	// C
	1995	v=combiner_map_input_select(combiner.stage[n].mapin_aC_input,2+combiner.stage[n].mapin_aC_component);
	1996	combiner.variable_C[3]=combiner_map_input_function(combiner.stage[n].mapin_aC_mapping,v);
	1997	// D
	1998	v=combiner_map_input_select(combiner.stage[n].mapin_aD_input,2+combiner.stage[n].mapin_aD_component);
	1999	combiner.variable_D[3]=combiner_map_input_function(combiner.stage[n].mapin_aD_mapping,v);
	2000
	2001	// A
	2002	pv=combiner_map_input_select3(combiner.stage[n].mapin_rgbA_input);
	2003	c=combiner.stage[n].mapin_rgbA_component*3;
	2004	i=~combiner.stage[n].mapin_rgbA_component & 1;
	2005	for (d=0;d < 3;d++) {
	2006	combiner.variable_A[d]=pv[c];
	2007	c=c+i;
	2008	}
	2009	combiner_map_input_function3(combiner.stage[n].mapin_rgbA_mapping,combiner.variable_A);
	2010	// B
	2011	pv=combiner_map_input_select3(combiner.stage[n].mapin_rgbB_input);
	2012	c=combiner.stage[n].mapin_rgbB_component*3;
	2013	i=~combiner.stage[n].mapin_rgbB_component & 1;
	2014	for (d=0;d < 3;d++) {
	2015	combiner.variable_B[d]=pv[c];
	2016	c=c+i;
	2017	}
	2018	combiner_map_input_function3(combiner.stage[n].mapin_rgbB_mapping,combiner.variable_B);
	2019	// C
	2020	pv=combiner_map_input_select3(combiner.stage[n].mapin_rgbC_input);
	2021	c=combiner.stage[n].mapin_rgbC_component*3;
	2022	i=~combiner.stage[n].mapin_rgbC_component & 1;
	2023	for (d=0;d < 3;d++) {
	2024	combiner.variable_C[d]=pv[c];
	2025	c=c+i;
	2026	}
	2027	combiner_map_input_function3(combiner.stage[n].mapin_rgbC_mapping,combiner.variable_C);
	2028	// D
	2029	pv=combiner_map_input_select3(combiner.stage[n].mapin_rgbD_input);
	2030	c=combiner.stage[n].mapin_rgbD_component*3;
	2031	i=~combiner.stage[n].mapin_rgbD_component & 1;
	2032	for (d=0;d < 3;d++) {
	2033	combiner.variable_D[d]=pv[c];
	2034	c=c+i;
	2035	}
	2036	combiner_map_input_function3(combiner.stage[n].mapin_rgbD_mapping,combiner.variable_D);
	2037	}
	2038
	2039	void nv2a_renderer::combiner_map_output(int stage_number)
	2040	{
	2041	int n=stage_number;
	2042	float *f;
	2043
	2044	// rgb
	2045	f=combiner_map_output_select3(combiner.stage[n].mapout_rgbAB_output);
	2046	if (f) {
	2047	f[0]=combiner.function_RGBop1[0];
	2048	f[1]=combiner.function_RGBop1[1];
	2049	f[2]=combiner.function_RGBop1[2];
	2050	}
	2051	f=combiner_map_output_select3(combiner.stage[n].mapout_rgbCD_output);
	2052	if (f) {
	2053	f[0]=combiner.function_RGBop2[0];
	2054	f[1]=combiner.function_RGBop2[1];
	2055	f[2]=combiner.function_RGBop2[2];
	2056	}
	2057	if ((combiner.stage[n].mapout_rgbAB_dotproduct | combiner.stage[n].mapout_rgbCD_dotproduct) == 0) {
	2058	f=combiner_map_output_select3(combiner.stage[n].mapout_rgbSUM_output);
	2059	if (f) {
	2060	f[0]=combiner.function_RGBop3[0];
	2061	f[1]=combiner.function_RGBop3[1];
	2062	f[2]=combiner.function_RGBop3[2];
	2063	}
	2064	}
	2065	// a
	2066	f=combiner_map_output_select3(combiner.stage[n].mapout_aAB_output);
	2067	if (f)
	2068	f[3]=combiner.function_Aop1;
	2069	f=combiner_map_output_select3(combiner.stage[n].mapout_aCD_output);
	2070	if (f)
	2071	f[3]=combiner.function_Aop2;
	2072	f=combiner_map_output_select3(combiner.stage[n].mapout_aSUM_output);
	2073	if (f)
	2074	f[3]=combiner.function_Aop3;
	2075	}
	2076
	2077	void nv2a_renderer::combiner_map_final_input()
	2078	{
	2079	int i,c,d;
	2080	float *pv;
	2081
	2082	// E
	2083	pv=combiner_map_input_select3(combiner.final.mapin_rgbE_input);
	2084	c=combiner.final.mapin_rgbE_component*3;
	2085	i=~combiner.final.mapin_rgbE_component & 1;
	2086	for (d=0;d < 3;d++) {
	2087	combiner.variable_E[d]=pv[c];
	2088	c=c+i;
	2089	}
	2090	combiner_map_input_function3(combiner.final.mapin_rgbE_mapping,combiner.variable_E);
	2091	// F
	2092	pv=combiner_map_input_select3(combiner.final.mapin_rgbF_input);
	2093	c=combiner.final.mapin_rgbF_component*3;
	2094	i=~combiner.final.mapin_rgbF_component & 1;
	2095	for (d=0;d < 3;d++) {
	2096	combiner.variable_F[d]=pv[c];
	2097	c=c+i;
	2098	}
	2099	combiner_map_input_function3(combiner.final.mapin_rgbF_mapping,combiner.variable_F);
	2100	// EF
	2101	combiner.variable_EF[0]=combiner.variable_E[0]*combiner.variable_F[0];
	2102	combiner.variable_EF[1]=combiner.variable_E[1]*combiner.variable_F[1];
	2103	combiner.variable_EF[2]=combiner.variable_E[2]*combiner.variable_F[2];
	2104	// sumclamp
	2105	combiner.variable_sumclamp[0]=MAX(0,combiner.register_spare0[0])+MAX(0,combiner.register_secondarycolor[0]);
	2106	combiner.variable_sumclamp[1]=MAX(0,combiner.register_spare0[1])+MAX(0,combiner.register_secondarycolor[1]);
	2107	combiner.variable_sumclamp[2]=MAX(0,combiner.register_spare0[2])+MAX(0,combiner.register_secondarycolor[2]);
	2108	if (combiner.final.color_sum_clamp != 0) {
	2109	combiner.variable_sumclamp[0]=MIN(combiner.variable_sumclamp[0],1.0);
	2110	combiner.variable_sumclamp[1]=MIN(combiner.variable_sumclamp[1],1.0);
	2111	combiner.variable_sumclamp[2]=MIN(combiner.variable_sumclamp[2],1.0);
	2112	}
	2113	// A
	2114	pv=combiner_map_input_select3(combiner.final.mapin_rgbA_input);
	2115	c=combiner.final.mapin_rgbA_component*3;
	2116	i=~combiner.final.mapin_rgbA_component & 1;
	2117	for (d=0;d < 3;d++) {
	2118	combiner.variable_A[d]=pv[c];
	2119	c=c+i;
	2120	}
	2121	combiner_map_input_function3(combiner.final.mapin_rgbA_mapping,combiner.variable_A);
	2122	// B
	2123	pv=combiner_map_input_select3(combiner.final.mapin_rgbB_input);
	2124	c=combiner.final.mapin_rgbB_component*3;
	2125	i=~combiner.final.mapin_rgbB_component & 1;
	2126	for (d=0;d < 3;d++) {
	2127	combiner.variable_B[d]=pv[c];
	2128	c=c+i;
	2129	}
	2130	combiner_map_input_function3(combiner.final.mapin_rgbB_mapping,combiner.variable_B);
	2131	// C
	2132	pv=combiner_map_input_select3(combiner.final.mapin_rgbC_input);
	2133	c=combiner.final.mapin_rgbC_component*3;
	2134	i=~combiner.final.mapin_rgbC_component & 1;
	2135	for (d=0;d < 3;d++) {
	2136	combiner.variable_C[d]=pv[c];
	2137	c=c+i;
	2138	}
	2139	combiner_map_input_function3(combiner.final.mapin_rgbC_mapping,combiner.variable_C);
	2140	// D
	2141	pv=combiner_map_input_select3(combiner.final.mapin_rgbD_input);
	2142	c=combiner.final.mapin_rgbD_component*3;
	2143	i=~combiner.final.mapin_rgbD_component & 1;
	2144	for (d=0;d < 3;d++) {
	2145	combiner.variable_D[d]=pv[c];
	2146	c=c+i;
	2147	}
	2148	combiner_map_input_function3(combiner.final.mapin_rgbD_mapping,combiner.variable_D);
	2149	// G
	2150	combiner.variable_G=combiner_map_input_select(combiner.final.mapin_aG_input,2+combiner.final.mapin_aG_component);
	2151	}
	2152
	2153	void nv2a_renderer::combiner_final_output()
	2154	{
	2155	// rgb
	2156	combiner.output[0]=combiner.variable_A[0]*combiner.variable_B[0]+(1.0-combiner.variable_A[0])*combiner.variable_C[0]+combiner.variable_D[0];
	2157	combiner.output[1]=combiner.variable_A[1]*combiner.variable_B[1]+(1.0-combiner.variable_A[1])*combiner.variable_C[1]+combiner.variable_D[1];
	2158	combiner.output[2]=combiner.variable_A[2]*combiner.variable_B[2]+(1.0-combiner.variable_A[2])*combiner.variable_C[2]+combiner.variable_D[2];
	2159	combiner.output[0]=MIN(combiner.output[0],1.0);
	2160	combiner.output[1]=MIN(combiner.output[1],1.0);
	2161	combiner.output[2]=MIN(combiner.output[2],1.0);
	2162	// a
	2163	combiner.output[3]=combiner_map_input_function(combiner.final.mapin_aG_mapping,combiner.variable_G);
	2164	}
	2165
	2166	void nv2a_renderer::combiner_function_AB(float result[4])
	2167	{
	2168	result[0]=combiner.variable_A[0]*combiner.variable_B[0];
	2169	result[1]=combiner.variable_A[1]*combiner.variable_B[1];
	2170	result[2]=combiner.variable_A[2]*combiner.variable_B[2];
	2171	}
	2172
	2173	void nv2a_renderer::combiner_function_AdotB(float result[4])
	2174	{
	2175	result[0]=combiner.variable_A[0]*combiner.variable_B[0]+combiner.variable_A[1]*combiner.variable_B[1]+combiner.variable_A[2]*combiner.variable_B[2];
	2176	result[1]=result[0];
	2177	result[2]=result[0];
	2178	}
	2179
	2180	void nv2a_renderer::combiner_function_CD(float result[4])
	2181	{
	2182	result[0]=combiner.variable_C[0]*combiner.variable_D[0];
	2183	result[1]=combiner.variable_C[1]*combiner.variable_D[1];
	2184	result[2]=combiner.variable_C[2]*combiner.variable_D[2];
	2185	}
	2186
	2187	void nv2a_renderer::combiner_function_CdotD(float result[4])
	2188	{
	2189	result[0]=combiner.variable_C[0]*combiner.variable_D[0]+combiner.variable_C[1]*combiner.variable_D[1]+combiner.variable_C[2]*combiner.variable_D[2];
	2190	result[1]=result[0];
	2191	result[2]=result[0];
	2192	}
	2193
	2194	void nv2a_renderer::combiner_function_ABmuxCD(float result[4])
	2195	{
	2196	if (combiner.register_spare0[3] >= 0.5)
	2197	combiner_function_AB(result);
	2198	else
	2199	combiner_function_CD(result);
	2200	}
	2201
	2202	void nv2a_renderer::combiner_function_ABsumCD(float result[4])
	2203	{
	2204	result[0]=combiner.variable_A[0]*combiner.variable_B[0]+combiner.variable_C[0]*combiner.variable_D[0];
	2205	result[1]=combiner.variable_A[1]*combiner.variable_B[1]+combiner.variable_C[1]*combiner.variable_D[1];
	2206	result[2]=combiner.variable_A[2]*combiner.variable_B[2]+combiner.variable_C[2]*combiner.variable_D[2];
	2207	}
	2208
	2209	void nv2a_renderer::combiner_compute_rgb_outputs(int stage_number)
	2210	{
	2211	int n=stage_number;
	2212	int m;
	2213	float biasrgb,scalergb;
	2214
	2215	if (combiner.stage[n].mapout_rgb_bias)
	2216	biasrgb= -0.5;
	2217	else
	2218	biasrgb=0;
	2219	switch (combiner.stage[n].mapout_rgb_scale) {
	2220	case 0:
	2221	default:
	2222	scalergb=1.0;
	2223	break;
	2224	case 1:
	2225	scalergb=2.0;
	2226	break;
	2227	case 2:
	2228	scalergb=4.0;
	2229	break;
	2230	case 3:
	2231	scalergb=0.5;
	2232	break;
	2233	}
	2234	if (combiner.stage[n].mapout_rgbAB_dotproduct) {
	2235	m=1;
	2236	combiner_function_AdotB(combiner.function_RGBop1);
	2237	} else {
	2238	m=0;
	2239	combiner_function_AB(combiner.function_RGBop1);
	2240	}
	2241	combiner.function_RGBop1[0]=MAX(MIN((combiner.function_RGBop1[0] + biasrgb) * scalergb, 1.0), -1.0);
	2242	combiner.function_RGBop1[1]=MAX(MIN((combiner.function_RGBop1[1] + biasrgb) * scalergb, 1.0), -1.0);
	2243	combiner.function_RGBop1[2]=MAX(MIN((combiner.function_RGBop1[2] + biasrgb) * scalergb, 1.0), -1.0);
	2244	if (combiner.stage[n].mapout_rgbCD_dotproduct) {
	2245	m=m | 1;
	2246	combiner_function_CdotD(combiner.function_RGBop2);
	2247	} else
	2248	combiner_function_CD(combiner.function_RGBop2);
	2249	combiner.function_RGBop2[0]=MAX(MIN((combiner.function_RGBop2[0] + biasrgb) * scalergb, 1.0), -1.0);
	2250	combiner.function_RGBop2[1]=MAX(MIN((combiner.function_RGBop2[1] + biasrgb) * scalergb, 1.0), -1.0);
	2251	combiner.function_RGBop2[2]=MAX(MIN((combiner.function_RGBop2[2] + biasrgb) * scalergb, 1.0), -1.0);
	2252	if (m == 0) {
	2253	if (combiner.stage[n].mapout_rgb_muxsum)
	2254	combiner_function_ABmuxCD(combiner.function_RGBop3);
	2255	else
	2256	combiner_function_ABsumCD(combiner.function_RGBop3);
	2257	combiner.function_RGBop3[0]=MAX(MIN((combiner.function_RGBop3[0] + biasrgb) * scalergb, 1.0), -1.0);
	2258	combiner.function_RGBop3[1]=MAX(MIN((combiner.function_RGBop3[1] + biasrgb) * scalergb, 1.0), -1.0);
	2259	combiner.function_RGBop3[2]=MAX(MIN((combiner.function_RGBop3[2] + biasrgb) * scalergb, 1.0), -1.0);
	2260	}
	2261	}
	2262
	2263	void nv2a_renderer::combiner_compute_a_outputs(int stage_number)
	2264	{
	2265	int n=stage_number;
	2266	float biasa,scalea;
	2267
	2268	if (combiner.stage[n].mapout_a_bias)
	2269	biasa= -0.5;
	2270	else
	2271	biasa=0;
	2272	switch (combiner.stage[n].mapout_a_scale) {
	2273	case 0:
	2274	default:
	2275	scalea=1.0;
	2276	break;
	2277	case 1:
	2278	scalea=2.0;
	2279	break;
	2280	case 2:
	2281	scalea=4.0;
	2282	break;
	2283	case 3:
	2284	scalea=0.5;
	2285	break;
	2286	}
	2287	combiner.function_Aop1=combiner.variable_A[3]*combiner.variable_B[3];
	2288	combiner.function_Aop1=MAX(MIN((combiner.function_Aop1 + biasa) * scalea, 1.0), -1.0);
	2289	combiner.function_Aop2=combiner.variable_C[3]*combiner.variable_D[3];
	2290	combiner.function_Aop2=MAX(MIN((combiner.function_Aop2 + biasa) * scalea, 1.0), -1.0);
	2291	if (combiner.stage[n].mapout_a_muxsum) {
	2292	if (combiner.register_spare0[3] >= 0.5)
	2293	combiner.function_Aop3=combiner.variable_A[3]*combiner.variable_B[3];
	2294	else
	2295	combiner.function_Aop3=combiner.variable_C[3]*combiner.variable_D[3];
	2296	} else
	2297	combiner.function_Aop3=combiner.variable_A[3]*combiner.variable_B[3]+combiner.variable_C[3]*combiner.variable_D[3];
	2298	combiner.function_Aop3=MAX(MIN((combiner.function_Aop3 + biasa) * scalea, 1.0), -1.0);
	2299	}
	2300
1103	2301	void nv2a_renderer::vblank_callback(screen_device &screen, bool state)
1104	2302	{
1105	2303	chihiro_state *chst=machine().driver_data<chihiro_state>();
r21575	r21576
1125	2323	UINT32 *dst=(UINT32 *)bitmap.raw_pixptr(0,0);
1126	2324	UINT32 *src=(UINT32 *)fb.raw_pixptr(0,0);
1127	2325
	2326	printf("updatescreen\n\r");
1128	2327	memcpy(dst,src,bitmap.rowbytes()*bitmap.height());
1129	2328	return 0;
1130	2329	}
r21575	r21576
1164	2363	} else if ((offset >= 0x00600000/4) && (offset < 0x00601000/4)) {
1165	2364	ret=pcrtc[offset-0x00600000/4];
1166	2365	logerror("NV_2A: read PCRTC[%06X] value %08X\n",offset*4-0x00600000,ret);
1167		} else if (                             offset < 0x00001000/4) {
1168		ret=pmc[offset];
	2366	} else if ((offset >= 0x00000000/4) && (offset < 0x00001000/4)) {
	2367	ret=pmc[offset-0x00000000/4];
1169	2368	logerror("NV_2A: read PMC[%06X] value %08X\n",offset*4-0x00000000,ret);
1170	2369	} else if ((offset >= 0x00800000/4) && (offset < 0x00900000/4)) {
1171	2370	// 32 channels size 0x10000 each, 8 subchannels per channel size 0x2000 each
r21575	r21576
1199	2398	} else if ((offset >= 0x00600000/4) && (offset < 0x00601000/4)) {
1200	2399	COMBINE_DATA(pcrtc+offset-0x00600000/4);
1201	2400	logerror("NV_2A: write PCRTC[%06X]=%08X\n",offset*4-0x00600000,data & mem_mask);
1202		} else if (                             offset < 0x00001000/4) {
1203		COMBINE_DATA(pmc+offset);
	2401	} else if ((offset >= 0x00000000/4) && (offset < 0x00001000/4)) {
	2402	COMBINE_DATA(pmc+offset-0x00000000/4);
1204	2403	logerror("NV_2A: write PMC[%06X]=%08X\n",offset*4-0x00000000,data & mem_mask);
1205	2404	} else if ((offset >= 0x00800000/4) && (offset < 0x00900000/4)) {
1206	2405	// 32 channels size 0x10000 each, 8 subchannels per channel size 0x2000 each
1207	2406	int chanel,subchannel,suboffset;
1208		int method,subch,count,handle,objclass;
	2407	int method,count,handle,objclass;
	2408	#ifdef LOG_NV2A
	2409	int subch;
	2410	#endif
1209	2411
1210	2412	suboffset=offset-0x00800000/4;
1211	2413	chanel=(suboffset >> (16-2)) & 31;
r21575	r21576
1221	2423
1222	2424	dmaput=&channel[chanel][subchannel].regs[0x40/4];
1223	2425	dmaget=&channel[chanel][subchannel].regs[0x44/4];
1224		printf("dmaget %08X dmaput %08X\n\r",*dmaget,*dmaput); // 7fcbe08 7f4d018
	2426	//printf("dmaget %08X dmaput %08X\n\r",*dmaget,*dmaput);
1225	2427	while (*dmaget != *dmaput) {
1226	2428	cmd=space.read_dword(*dmaget);
1227	2429	*dmaget += 4;
r21575	r21576
1229	2431	switch (cmdtype)
1230	2432	{
1231	2433	case 6: // jump
	2434	#ifdef LOG_NV2A
1232	2435	printf("jump dmaget %08X",*dmaget);
	2436	#endif
1233	2437	*dmaget=cmd & 0xfffffffc;
	2438	#ifdef LOG_NV2A
1234	2439	printf(" -> %08X\n\r",*dmaget);
	2440	#endif
1235	2441	break;
1236	2442	case 0: // increasing method
1237	2443	method=(cmd >> 2) & 2047; // method*4 is address // if method >= 0x40 send it to assigned object
	2444	#ifdef LOG_NV2A
1238	2445	subch=(cmd >> 13) & 7;
	2446	#endif
1239	2447	count=(cmd >> 18) & 2047;
1240	2448	if ((method == 0) && (count == 1)) {
1241	2449	handle=space.read_dword(*dmaget);
1242	2450	handle=geforce_object_offset(handle);
	2451	#ifdef LOG_NV2A
1243	2452	logerror("  assign to subchannel %d object at %d\n",subch,handle);
	2453	#endif
1244	2454	channel[chanel][subchannel].object.objhandle=handle;
1245	2455	handle=ramin[handle/4];
1246	2456	objclass=handle & 0xff;
1247	2457	channel[chanel][subchannel].object.objclass=objclass;
1248	2458	*dmaget += 4;
1249	2459	} else {
	2460	#ifdef LOG_NV2A
1250	2461	logerror("  subch. %d method %04x offset %04x count %d\n",subch,method,method*4,count);
	2462	#endif
1251	2463	while (count > 0) {
1252	2464	geforce_exec_method(space,chanel,subchannel,method,space.read_dword(*dmaget));
1253	2465	count--;
r21575	r21576
1258	2470	break;
1259	2471	case 5: // non-increasing method
1260	2472	method=(cmd >> 2) & 2047;
	2473	#ifdef LOG_NV2A
1261	2474	subch=(cmd >> 13) & 7;
	2475	#endif
1262	2476	count=(cmd >> 18) & 2047;
1263	2477	if ((method == 0) && (count == 1)) {
	2478	#ifdef LOG_NV2A
1264	2479	logerror("  assign channel %d\n",subch);
	2480	#endif
1265	2481	handle=space.read_dword(*dmaget);
1266	2482	handle=geforce_object_offset(handle);
	2483	#ifdef LOG_NV2A
1267	2484	logerror("  assign to subchannel %d object at %d\n",subch,handle);
	2485	#endif
1268	2486	channel[chanel][subchannel].object.objhandle=handle;
1269	2487	handle=ramin[handle/4];
1270	2488	objclass=handle & 0xff;
1271	2489	channel[chanel][subchannel].object.objclass=objclass;
1272	2490	*dmaget += 4;
1273	2491	} else {
	2492	#ifdef LOG_NV2A
1274	2493	logerror("  subch. %d method %04x offset %04x count %d\n",subch,method,method*4,count);
	2494	#endif
1275	2495	while (count > 0) {
1276	2496	geforce_exec_method(space,chanel,subchannel,method,space.read_dword(*dmaget));
1277	2497	count--;
r21575	r21576
1281	2501	break;
1282	2502	case 3: // long non-increasing method
1283	2503	method=(cmd >> 2) & 2047;
	2504	#ifdef LOG_NV2A
1284	2505	subch=(cmd >> 13) & 7;
	2506	#endif
1285	2507	count=space.read_dword(*dmaget);
1286	2508	*dmaget += 4;
1287	2509	if ((method == 0) && (count == 1)) {
1288	2510	handle=space.read_dword(*dmaget);
1289	2511	handle=geforce_object_offset(handle);
	2512	#ifdef LOG_NV2A
1290	2513	logerror("  assign to subchannel %d object at %d\n",subch,handle);
	2514	#endif
1291	2515	channel[chanel][subchannel].object.objhandle=handle;
1292	2516	handle=ramin[handle/4];
1293	2517	objclass=handle & 0xff;
1294	2518	channel[chanel][subchannel].object.objclass=objclass;
1295	2519	*dmaget += 4;
1296	2520	} else {
	2521	#ifdef LOG_NV2A
1297	2522	logerror("  subch. %d method %04x offset %04x count %d\n",subch,method,method*4,count);
	2523	#endif
1298	2524	while (count > 0) {
1299	2525	geforce_exec_method(space,chanel,subchannel,method,space.read_dword(*dmaget));
1300	2526	count--;
r21575	r21576
1457	2683
1458	2684	offset *= 4;
1459	2685	size = convert_to_offset_and_size32(&offset, mem_mask);
1460
1461	2686	return ide_controller_r(chihiro_devs.ide, offset+0x01f0, size) << ((offset & 3) * 8);
1462	2687	}
1463	2688
r21575	r21576
1468	2693	offset *= 4;
1469	2694	size = convert_to_offset_and_size32(&offset, mem_mask);
1470	2695	data = data >> ((offset & 3) * 8);
1471
1472	2696	ide_controller_w(chihiro_devs.ide, offset+0x01f0, size, data);
1473	2697	}
1474	2698
r21575	r21576
1534	2758
1535	2759	logerror("baseboard: read sector lba %08x\n",lba);
1536	2760	off=(lba&0x7ff)*512;
1537		data=memregion("others")->base();
	2761	data=memregion(":others")->base();
1538	2762	memcpy(buffer,data+off,512);
1539	2763	return 1;
1540	2764	}

trunk/src/emu/machine/idectrl.c

r21575	r21576
1732	1732
1733	1733	ide_controller_device::ide_controller_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
1734	1734	device_t(mconfig, IDE_CONTROLLER, "IDE Controller", tag, owner, clock),
	1735	status(0),
	1736	adapter_control(0),
	1737	error(0),
	1738	command(0),
	1739	interrupt_pending(0),
	1740	precomp_offset(0),
	1741	buffer_offset(0),
	1742	sector_count(0),
	1743	block_count(0),
	1744	sectors_until_int(0),
	1745	verify_only(0),
	1746	dma_active(0),
	1747	dma_space(NULL),
	1748	dma_address_xor(0),
	1749	dma_last_buffer(0),
	1750	dma_address(0),
	1751	dma_descriptor(0),
	1752	dma_bytes_left(0),
	1753	bus_master_command(0),
	1754	bus_master_status(0),
	1755	bus_master_descriptor(0),
	1756	config_unknown(0),
	1757	config_register_num(0),
	1758	master_password_enable(0),
	1759	user_password_enable(0),
1735	1760	master_password(NULL),
1736	1761	user_password(NULL),
	1762	gnetreadlock(0),
	1763	cur_drive(0),
1737	1764	m_irq_handler(*this),
1738	1765	bmcpu(NULL),
1739	1766	bmspace(0)

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team