Previous

199869 Revisions

Next

r32522 Saturday 4th October, 2014 at 06:26:33 UTC by Osso
micro3d: moved video functions into the driver class (nw)

[src/mame/includes]	micro3d.h
[src/mame/video]	micro3d.c

trunk/src/mame/includes/micro3d.h

r32521	r32522
15	15	#define DRMATH_MONITOR_DISPLAY      0
16	16
17	17
	18	struct micro3d_vtx
	19	{
	20	INT32 x, y, z;
	21	};
	22
	23	enum planes
	24	{
	25	CLIP_Z_MIN,
	26	CLIP_Z_MAX,
	27	CLIP_X_MIN,
	28	CLIP_X_MAX,
	29	CLIP_Y_MIN,
	30	CLIP_Y_MAX,
	31	};
	32
18	33	class micro3d_state : public driver_device
19	34	{
20	35	public:
r32521	r32522
26	41
27	42	micro3d_state(const machine_config &mconfig, device_type type, const char *tag)
28	43	: driver_device(mconfig, type, tag),
29		m_shared_ram(*this, "shared_ram"),
30		m_mac_sram(*this, "mac_sram"),
31		m_micro3d_sprite_vram(*this, "sprite_vram"),
32	44	m_maincpu(*this, "maincpu"),
33	45	m_audiocpu(*this, "audiocpu"),
34	46	m_upd7759(*this, "upd7759"),
r32521	r32522
36	48	m_vgb(*this, "vgb"),
37	49	m_palette(*this, "palette"),
38	50	m_duart68681(*this, "duart68681"),
39		m_generic_paletteram_16(*this, "paletteram") { }
	51	m_generic_paletteram_16(*this, "paletteram"),
	52	m_shared_ram(*this, "shared_ram"),
	53	m_mac_sram(*this, "mac_sram"),
	54	m_sprite_vram(*this, "sprite_vram") { }
	55
	56	required_device<cpu_device> m_maincpu;
	57	required_device<i8051_device> m_audiocpu;
	58	required_device<upd7759_device> m_upd7759;
	59	required_device<cpu_device> m_drmath;
	60	required_device<tms34010_device> m_vgb;
	61	required_device<palette_device> m_palette;
	62	required_device<mc68681_device> m_duart68681;
	63	required_shared_ptr<UINT16> m_generic_paletteram_16;
40	64
41	65	required_shared_ptr<UINT16> m_shared_ram;
42	66	UINT8               m_m68681_tx0;
r32521	r32522
66	90	UINT32              m_mac_inst;
67	91
68	92	/* 2D video */
69		required_shared_ptr<UINT16> m_micro3d_sprite_vram;
	93	required_shared_ptr<UINT16> m_sprite_vram;
70	94	UINT16              m_creg;
71	95	UINT16              m_xfer3dk;
72	96
r32521	r32522
140	164	DECLARE_WRITE_LINE_MEMBER(tms_interrupt);
141	165	TMS340X0_SCANLINE_IND16_CB_MEMBER(scanline_update);
142	166
143		required_device<cpu_device> m_maincpu;
144		required_device<i8051_device> m_audiocpu;
145		required_device<upd7759_device> m_upd7759;
146		required_device<cpu_device> m_drmath;
147		required_device<tms34010_device> m_vgb;
148		required_device<palette_device> m_palette;
149		required_device<mc68681_device> m_duart68681;
150		required_shared_ptr<UINT16> m_generic_paletteram_16;
	167	/* 3D graphics */
	168	int inside(micro3d_vtx *v, enum planes plane);
	169	micro3d_vtx intersect(micro3d_vtx *v1, micro3d_vtx *v2, enum planes plane);
	170	inline void write_span(UINT32 y, UINT32 x);
	171	void draw_line(UINT32 x1, UINT32 y1, UINT32 x2, UINT32 y2);
	172	void rasterise_spans(UINT32 min_y, UINT32 max_y, UINT32 attr);
	173	int clip_triangle(micro3d_vtx *v, micro3d_vtx *vout, int num_vertices, enum planes plane);
	174	void draw_triangles(UINT32 attr);
	175
151	176
152	177	protected:
153	178	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
154	179	};
155	180
156		struct micro3d_vtx
157		{
158		INT32 x, y, z;
159		};
160
161	181	/*----------- defined in audio/micro3d.c -----------*/
162	182
163	183	struct biquad

trunk/src/mame/video/micro3d.c

r32521	r32522
62	62
63	63	TMS340X0_SCANLINE_IND16_CB_MEMBER(micro3d_state::scanline_update)
64	64	{
65		UINT16 *src = &m_micro3d_sprite_vram[(params->rowaddr << 8) & 0x7fe00];
	65	UINT16 *src = &m_sprite_vram[(params->rowaddr << 8) & 0x7fe00];
66	66	UINT16 *dest = &bitmap.pix16(scanline);
67	67	int coladdr = params->coladdr;
68	68	int sd_11_7 = (m_creg & 0x1f) << 7;
r32521	r32522
135	135	*
136	136	*************************************/
137	137
138		enum planes
	138	int micro3d_state::inside(micro3d_vtx *v, enum planes plane)
139	139	{
140		CLIP_Z_MIN,
141		CLIP_Z_MAX,
142		CLIP_X_MIN,
143		CLIP_X_MAX,
144		CLIP_Y_MIN,
145		CLIP_Y_MAX,
146		};
147
148		static int inside(micro3d_state *state, micro3d_vtx *v, enum planes plane)
149		{
150	140	switch (plane)
151	141	{
152		case CLIP_Z_MIN: return v->z >= state->m_z_min;
153		case CLIP_Z_MAX: return v->z <= state->m_z_max;
154		case CLIP_X_MIN: return v->x >= state->m_x_min;
155		case CLIP_X_MAX: return v->x <= state->m_x_max;
156		case CLIP_Y_MIN: return v->y >= state->m_y_min;
157		case CLIP_Y_MAX: return v->y <= state->m_y_max;
	142	case CLIP_Z_MIN: return v->z >= m_z_min;
	143	case CLIP_Z_MAX: return v->z <= m_z_max;
	144	case CLIP_X_MIN: return v->x >= m_x_min;
	145	case CLIP_X_MAX: return v->x <= m_x_max;
	146	case CLIP_Y_MIN: return v->y >= m_y_min;
	147	case CLIP_Y_MAX: return v->y <= m_y_max;
158	148	}
159	149
160	150	return 0;
161	151	}
162	152
163	153	/* Calculate where two points intersect */
164		static micro3d_vtx intersect(micro3d_state *state, micro3d_vtx *v1, micro3d_vtx *v2, enum planes plane)
	154	micro3d_vtx micro3d_state::intersect(micro3d_vtx *v1, micro3d_vtx *v2, enum planes plane)
165	155	{
166	156	float m = 0.0;
167	157	micro3d_vtx vo = { 0, 0, 0 };
r32521	r32522
186	176	myz = 0.0;
187	177	}
188	178
189		vo.x = v2->x + (state->m_z_min - v2->z) * mxz;
190		vo.y = v2->y + (state->m_z_min - v2->z) * myz;
191		vo.z = state->m_z_min;
	179	vo.x = v2->x + (m_z_min - v2->z) * mxz;
	180	vo.y = v2->y + (m_z_min - v2->z) * myz;
	181	vo.z = m_z_min;
192	182	break;
193	183	}
194	184	case CLIP_Z_MAX:
r32521	r32522
206	196	myz = 0.0;
207	197	}
208	198
209		vo.x = v2->x + (state->m_z_max - v2->z) * mxz;
210		vo.y = v2->y + (state->m_z_max - v2->z) * myz;
211		vo.z = state->m_z_max;
	199	vo.x = v2->x + (m_z_max - v2->z) * mxz;
	200	vo.y = v2->y + (m_z_max - v2->z) * myz;
	201	vo.z = m_z_max;
212	202	break;
213	203	}
214	204	case CLIP_X_MIN:
215	205	{
216		vo.x = state->m_x_min;
217		vo.y = v2->y + (state->m_x_min - v2->x) * m;
	206	vo.x = m_x_min;
	207	vo.y = v2->y + (m_x_min - v2->x) * m;
218	208	vo.z = 0;
219	209	break;
220	210	}
221	211	case CLIP_X_MAX:
222	212	{
223		vo.x = state->m_x_max;
224		vo.y = v2->y + (state->m_x_max - v2->x) * m;
	213	vo.x = m_x_max;
	214	vo.y = v2->y + (m_x_max - v2->x) * m;
225	215	vo.z = 0;
226	216	break;
227	217	}
228	218	case CLIP_Y_MIN:
229	219	{
230	220	if (v1->x != v2->x)
231		vo.x = v2->x + (state->m_y_min - v2->y) / m;
	221	vo.x = v2->x + (m_y_min - v2->y) / m;
232	222	else
233	223	vo.x = v2->x;
234	224
235		vo.y = state->m_y_min;
	225	vo.y = m_y_min;
236	226	vo.z = 0;
237	227	break;
238	228	}
239	229	case CLIP_Y_MAX:
240	230	{
241	231	if (v1->x != v2->x)
242		vo.x = v2->x + (state->m_y_max - v2->y) / m;
	232	vo.x = v2->x + (m_y_max - v2->y) / m;
243	233	else
244	234	vo.x = v2->x;
245	235
246		vo.y = state->m_y_max;
	236	vo.y = m_y_max;
247	237	vo.z = 0;
248	238	break;
249	239	}
r32521	r32522
251	241	return vo;
252	242	}
253	243
254		INLINE void write_span(micro3d_state *state, UINT32 y, UINT32 x)
	244	inline void micro3d_state::write_span(UINT32 y, UINT32 x)
255	245	{
256		UINT32 *draw_dpram = state->m_draw_dpram;
	246	UINT32 *draw_dpram = m_draw_dpram;
257	247	int addr = y << 1;
258	248
259	249	if (draw_dpram[addr] == 0x3ff000)
r32521	r32522
263	253	else
264	254	{
265	255	/* Check start */
266		if (x < (state->m_draw_dpram[addr] & 0x3ff))
	256	if (x < (m_draw_dpram[addr] & 0x3ff))
267	257	{
268	258	draw_dpram[addr] &= ~0x3ff;
269	259	draw_dpram[addr] |= x;
r32521	r32522
278	268	}
279	269
280	270	/* This is the same algorithm used in the 3D tests */
281		static void draw_line(micro3d_state *state, UINT32 x1, UINT32 y1, UINT32 x2, UINT32 y2)
	271	void micro3d_state::draw_line(UINT32 x1, UINT32 y1, UINT32 x2, UINT32 y2)
282	272	{
283	273	UINT32 tmp2;
284	274	UINT32 acc;
r32521	r32522
307	297	else
308	298	dy = y1 - y2;
309	299
310		write_span(state, y1, x1);
	300	write_span(y1, x1);
311	301
312	302	if (dx == 0 && dy == 0)
313	303	return;
r32521	r32522
329	319	{
330	320	if (~acc & 0x80000000)
331	321	{
332		write_span(state, y1, x1);
	322	write_span(y1, x1);
333	323	y1 += y_inc;
334	324	x1++;
335	325	acc += dy;
336		write_span(state, y1, x1);
	326	write_span(y1, x1);
337	327	}
338	328	else
339	329	{
r32521	r32522
344	334	}
345	335
346	336	if (x2 != x1)
347		write_span(state, y1, x2);
	337	write_span(y1, x2);
348	338
349	339	}
350	340	else
r32521	r32522
360	350	if (acc & 0x80000000)
361	351	{
362	352	acc += tmp2;
363		write_span(state, y1, x1);
	353	write_span(y1, x1);
364	354	y1 += y_inc;
365		write_span(state, y1, x1);
	355	write_span(y1, x1);
366	356	}
367	357	else
368	358	{
369		write_span(state, y1, x1);
	359	write_span(y1, x1);
370	360	x1++;
371	361	y1 += y_inc;
372		write_span(state, y1, x1);
	362	write_span(y1, x1);
373	363
374	364	acc += dy;
375	365	}
r32521	r32522
377	367	}
378	368
379	369	if (x2 != x1)
380		write_span(state, y1, x2);
	370	write_span(y1, x2);
381	371	}
382	372	}
383	373
384		static void rasterise_spans(micro3d_state *state, UINT32 min_y, UINT32 max_y, UINT32 attr)
	374	void micro3d_state::rasterise_spans(UINT32 min_y, UINT32 max_y, UINT32 attr)
385	375	{
386	376	int y;
387	377	int color = attr & 0xfff;
r32521	r32522
392	382	{
393	383	int x;
394	384	int addr = y << 1;
395		UINT16 *dest = &state->m_tmp_buffer[y * 1024];
	385	UINT16 *dest = &m_tmp_buffer[y * 1024];
396	386
397		if (state->m_draw_dpram[addr] == 0x3ff000)
	387	if (m_draw_dpram[addr] == 0x3ff000)
398	388	{
399	389	continue;
400	390	}
401	391	else
402	392	{
403		int start = state->m_draw_dpram[addr] & 0x3ff;
404		int end = (state->m_draw_dpram[addr] >> 12) & 0x3ff;
	393	int start = m_draw_dpram[addr] & 0x3ff;
	394	int end = (m_draw_dpram[addr] >> 12) & 0x3ff;
405	395
406	396	for (x = start; x <= end; ++x)
407	397	dest[x] = color;
r32521	r32522
433	423	{
434	424	int x;
435	425	int addr = y << 1;
436		UINT16 *dest = &state->m_tmp_buffer[y * 1024];
	426	UINT16 *dest = &m_tmp_buffer[y * 1024];
437	427
438		if (state->m_draw_dpram[addr] == 0x3ff000)
	428	if (m_draw_dpram[addr] == 0x3ff000)
439	429	{
440	430	continue;
441	431	}
442	432	else
443	433	{
444		int start = state->m_draw_dpram[addr] & 0x3ff;
445		int end = (state->m_draw_dpram[addr] >> 12) & 0x3ff;
	434	int start = m_draw_dpram[addr] & 0x3ff;
	435	int end = (m_draw_dpram[addr] >> 12) & 0x3ff;
446	436
447	437	for (x = start; x <= end; ++x)
448	438	{
r32521	r32522
459	449	}
460	450	}
461	451
462		static int clip_triangle(micro3d_state *state, micro3d_vtx *v, micro3d_vtx *vout, int num_vertices, enum planes plane)
	452	int micro3d_state::clip_triangle(micro3d_vtx *v, micro3d_vtx *vout, int num_vertices, enum planes plane)
463	453	{
464	454	micro3d_vtx clip_out[10];
465	455
r32521	r32522
469	459
470	460	for (i = 0; i < num_vertices; ++i)
471	461	{
472		int v1_in = inside(state, &v[i], plane);
473		int v2_in = inside(state, &v[prev_i], plane);
	462	int v1_in = inside(&v[i], plane);
	463	int v2_in = inside(&v[prev_i], plane);
474	464
475	465	/* Edge is inside */
476	466	if (v1_in && v2_in)
r32521	r32522
480	470	/* Edge is leaving */
481	471	else if (v1_in && !v2_in)
482	472	{
483		clip_out[clip_verts++] = intersect(state, &v[i], &v[prev_i], plane);
	473	clip_out[clip_verts++] = intersect(&v[i], &v[prev_i], plane);
484	474	clip_out[clip_verts++] = v[i];
485	475	}
486	476	/* Edge is entering */
487	477	else if (!v1_in && v2_in)
488	478	{
489		clip_out[clip_verts++] = intersect(state, &v[i], &v[prev_i], plane);
	479	clip_out[clip_verts++] = intersect(&v[i], &v[prev_i], plane);
490	480	}
491	481
492	482	prev_i = i;
r32521	r32522
496	486	return clip_verts;
497	487	}
498	488
499		static void draw_triangles(micro3d_state *state, UINT32 attr)
	489	void micro3d_state::draw_triangles(UINT32 attr)
500	490	{
501	491	int i;
502	492	int triangles = 0;
503		int vertices = state->m_fifo_idx / 3;
	493	int vertices = m_fifo_idx / 3;
504	494	int min_y = 0x3ff;
505	495	int max_y = 0;
506	496
r32521	r32522
508	498	if (vertices == 0)
509	499	{
510	500	int y;
511		int val = ((state->m_x_mid + 16) << 12) | state->m_x_mid;
	501	int val = ((m_x_mid + 16) << 12) | m_x_mid;
512	502
513		for (y = state->m_y_mid; y <= state->m_y_mid + 16; ++y)
514		state->m_draw_dpram[y << 1] = val;
	503	for (y = m_y_mid; y <= m_y_mid + 16; ++y)
	504	m_draw_dpram[y << 1] = val;
515	505
516	506	return;
517	507	}
r32521	r32522
525	515	micro3d_vtx vo, vm, vn;
526	516	micro3d_vtx vclip_list[10];
527	517
528		vo.x = state->m_vtx_fifo[0];
529		vo.y = state->m_vtx_fifo[1];
530		vo.z = state->m_vtx_fifo[2];
	518	vo.x = m_vtx_fifo[0];
	519	vo.y = m_vtx_fifo[1];
	520	vo.z = m_vtx_fifo[2];
531	521
532		vm.x = state->m_vtx_fifo[(i - 1) * 3 + 0];
533		vm.y = state->m_vtx_fifo[(i - 1) * 3 + 1];
534		vm.z = state->m_vtx_fifo[(i - 1) * 3 + 2];
	522	vm.x = m_vtx_fifo[(i - 1) * 3 + 0];
	523	vm.y = m_vtx_fifo[(i - 1) * 3 + 1];
	524	vm.z = m_vtx_fifo[(i - 1) * 3 + 2];
535	525
536		vn.x = state->m_vtx_fifo[i * 3 + 0];
537		vn.y = state->m_vtx_fifo[i * 3 + 1];
538		vn.z = state->m_vtx_fifo[i * 3 + 2];
	526	vn.x = m_vtx_fifo[i * 3 + 0];
	527	vn.y = m_vtx_fifo[i * 3 + 1];
	528	vn.z = m_vtx_fifo[i * 3 + 2];
539	529
540	530	vclip_list[0] = vo;
541	531	vclip_list[1] = vm;
542	532	vclip_list[2] = vn;
543	533
544	534	/* Clip against near Z and far Z planes */
545		clip_vertices = clip_triangle(state, vclip_list, vclip_list, clip_vertices, CLIP_Z_MIN);
546		clip_vertices = clip_triangle(state, vclip_list, vclip_list, clip_vertices, CLIP_Z_MAX);
	535	clip_vertices = clip_triangle(vclip_list, vclip_list, clip_vertices, CLIP_Z_MIN);
	536	clip_vertices = clip_triangle(vclip_list, vclip_list, clip_vertices, CLIP_Z_MAX);
547	537
548	538	/* Perform perspective divide */
549	539	for (k = 0; k < clip_vertices; ++k)
550	540	{
551		vclip_list[k].x = vclip_list[k].x * state->m_z_min / vclip_list[k].z;
552		vclip_list[k].y = vclip_list[k].y * state->m_z_min / vclip_list[k].z;
	541	vclip_list[k].x = vclip_list[k].x * m_z_min / vclip_list[k].z;
	542	vclip_list[k].y = vclip_list[k].y * m_z_min / vclip_list[k].z;
553	543	vclip_list[k].z = 0;
554	544	}
555	545
556	546	/* Perform screen-space clipping */
557		clip_vertices = clip_triangle(state, vclip_list, vclip_list, clip_vertices, CLIP_Y_MAX);
558		clip_vertices = clip_triangle(state, vclip_list, vclip_list, clip_vertices, CLIP_X_MIN);
559		clip_vertices = clip_triangle(state, vclip_list, vclip_list, clip_vertices, CLIP_X_MAX);
560		clip_vertices = clip_triangle(state, vclip_list, vclip_list, clip_vertices, CLIP_Y_MIN);
	547	clip_vertices = clip_triangle(vclip_list, vclip_list, clip_vertices, CLIP_Y_MAX);
	548	clip_vertices = clip_triangle(vclip_list, vclip_list, clip_vertices, CLIP_X_MIN);
	549	clip_vertices = clip_triangle(vclip_list, vclip_list, clip_vertices, CLIP_X_MAX);
	550	clip_vertices = clip_triangle(vclip_list, vclip_list, clip_vertices, CLIP_Y_MIN);
561	551
562	552	/* Rasterise */
563	553	if (clip_vertices >= 3)
r32521	r32522
567	557
568	558	triangles = TRUE;
569	559
570		a.x += state->m_x_mid;
571		a.y += state->m_y_mid;
	560	a.x += m_x_mid;
	561	a.y += m_y_mid;
572	562
573		b.x += state->m_x_mid;
574		b.y += state->m_y_mid;
	563	b.x += m_x_mid;
	564	b.y += m_y_mid;
575	565
576	566	/* Keep track of the y-extents so we don't have to scan every line later */
577	567	if (a.y < min_y)
r32521	r32522
585	575	max_y = b.y;
586	576
587	577	/* Draw the first line of the triangle/fan */
588		draw_line(state, a.x, a.y, b.x, b.y);
	578	draw_line(a.x, a.y, b.x, b.y);
589	579
590	580	for (k = 2; k < clip_vertices; ++k)
591	581	{
592	582	micro3d_vtx c = vclip_list[k];
593	583
594		c.x += state->m_x_mid;
595		c.y += state->m_y_mid;
	584	c.x += m_x_mid;
	585	c.y += m_y_mid;
596	586
597	587	if (c.y < min_y)
598	588	min_y = c.y;
599	589	if (c.y > max_y)
600	590	max_y = c.y;
601	591
602		draw_line(state, b.x, b.y, c.x, c.y);
603		draw_line(state, a.x, a.y, c.x, c.y);
	592	draw_line(b.x, b.y, c.x, c.y);
	593	draw_line(a.x, a.y, c.x, c.y);
604	594	b = c;
605	595	}
606	596	}
607	597	}
608	598
609	599	if (triangles == TRUE)
610		rasterise_spans(state, min_y, max_y, attr);
	600	rasterise_spans(min_y, max_y, attr);
611	601	}
612	602
613	603
r32521	r32522
724	714	{
725	715	if ((opcode == 0x85) || (opcode == 0x8a))
726	716	{
727		micro3d_state *state = machine().driver_data<micro3d_state>();
728		draw_triangles(state, data);
	717	draw_triangles(data);
729	718	m_draw_state = STATE_DRAW_CMD;
730	719	}
731	720	else

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team