Previous

199869 Revisions

Next

r36186 Monday 2nd March, 2015 at 17:27:30 UTC by Osso
jalblend.c: converted to be a device (nw)

[src/mame/drivers]	argus.c psychic5.c
[src/mame/includes]	argus.h psychic5.h
[src/mame/video]	argus.c jalblend.c jalblend.h psychic5.c

trunk/src/mame/drivers/argus.c

r244697	r244698
548	548
549	549	MCFG_GFXDECODE_ADD("gfxdecode", "palette", argus)
550	550	MCFG_PALETTE_ADD("palette", 896)
	551
	552	MCFG_DEVICE_ADD("blend", JALECO_BLEND, 0)
551	553
552	554	MCFG_VIDEO_START_OVERRIDE(argus_state,argus)
553	555	MCFG_VIDEO_RESET_OVERRIDE(argus_state,argus)
r244697	r244698
592	594
593	595	MCFG_GFXDECODE_ADD("gfxdecode", "palette", valtric)
594	596	MCFG_PALETTE_ADD("palette", 768)
	597
	598	MCFG_DEVICE_ADD("blend", JALECO_BLEND, 0)
595	599
596	600	MCFG_VIDEO_START_OVERRIDE(argus_state,valtric)
597	601	MCFG_VIDEO_RESET_OVERRIDE(argus_state,valtric)
r244697	r244698
636	640
637	641	MCFG_GFXDECODE_ADD("gfxdecode", "palette", butasan)
638	642	MCFG_PALETTE_ADD("palette", 768)
	643
	644	MCFG_DEVICE_ADD("blend", JALECO_BLEND, 0)
639	645
640	646	MCFG_VIDEO_START_OVERRIDE(argus_state,butasan)
641	647	MCFG_VIDEO_RESET_OVERRIDE(argus_state,butasan)

trunk/src/mame/drivers/psychic5.c

r244697	r244698
722	722	MCFG_GFXDECODE_ADD("gfxdecode", "palette", psychic5)
723	723	MCFG_PALETTE_ADD("palette", 768)
724	724
	725	MCFG_DEVICE_ADD("blend", JALECO_BLEND, 0)
	726
725	727	MCFG_VIDEO_START_OVERRIDE(psychic5_state,psychic5)
726	728	MCFG_VIDEO_RESET_OVERRIDE(psychic5_state,psychic5)
727	729

trunk/src/mame/includes/argus.h

r244697	r244698
	1	#include "video/jalblend.h"
	2
1	3	class argus_state : public driver_device
2	4	{
3	5	public:
r244697	r244698
8	10	m_gfxdecode(*this, "gfxdecode"),
9	11	m_screen(*this, "screen"),
10	12	m_palette(*this, "palette"),
	13	m_blend(*this, "blend"),
11	14	m_bg0_scrollx(*this, "bg0_scrollx"),
12	15	m_bg0_scrolly(*this, "bg0_scrolly"),
13	16	m_bg1_scrollx(*this, "bg1_scrollx"),
r244697	r244698
23	26	required_device<gfxdecode_device> m_gfxdecode;
24	27	required_device<screen_device> m_screen;
25	28	required_device<palette_device> m_palette;
	29	required_device<jaleco_blend_device> m_blend;
26	30
27	31	optional_shared_ptr<UINT8> m_bg0_scrollx;
28	32	optional_shared_ptr<UINT8> m_bg0_scrolly;

trunk/src/mame/includes/psychic5.h

r244697	r244698
1	1	#include "machine/bankdev.h"
	2	#include "video/jalblend.h"
2	3
3	4	class psychic5_state : public driver_device
4	5	{
r244697	r244698
10	11	m_gfxdecode(*this, "gfxdecode"),
11	12	m_palette(*this, "palette"),
12	13	m_vrambank(*this, "vrambank"),
	14	m_blend(*this, "blend"),
13	15	m_spriteram(*this, "spriteram"),
14	16	m_fg_videoram(*this, "fg_videoram"),
15	17	m_bg_videoram(*this, "bg_videoram"),
r244697	r244698
25	27	required_device<gfxdecode_device> m_gfxdecode;
26	28	required_device<palette_device> m_palette;
27	29	optional_device<address_map_bank_device> m_vrambank;
	30	optional_device<jaleco_blend_device> m_blend;
	31
28	32	required_shared_ptr<UINT8> m_spriteram;
29	33	required_shared_ptr<UINT8> m_fg_videoram;
30	34	required_shared_ptr<UINT8> m_bg_videoram;
r244697	r244698
83	87	void change_bg_palette(int color, int lo_offs, int hi_offs);
84	88	void set_background_palette_intensity();
85	89	void draw_sprites(bitmap_rgb32 &bitmap, const rectangle &cliprect);
86		void draw_background(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	90	void draw_background(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); //only used by psychic5
87	91	};

trunk/src/mame/video/argus.c

r244697	r244698
114	114	***************************************************************************/
115	115
116	116	#include "emu.h"
117		#include "video/jalblend.h"
118	117	#include "includes/argus.h"
119	118
120	119
r244697	r244698
271	270	/* dummy RAM for back ground */
272	271	m_dummy_bg0ram = auto_alloc_array(machine(), UINT8, 0x800);
273	272
274		jal_blend_init(machine(), 1);
275
276	273	save_item(NAME(m_bg_status));
277	274	save_item(NAME(m_flipscreen));
278	275	save_item(NAME(m_palette_intensity));
r244697	r244698
301	298
302	299	m_screen->register_screen_bitmap(m_mosaicbitmap);
303	300
304		jal_blend_init(machine(), 1);
305
306	301	save_item(NAME(m_bg_status));
307	302	save_item(NAME(m_flipscreen));
308	303	save_item(NAME(m_palette_intensity));
r244697	r244698
335	330	m_butasan_txram      = &m_butasan_pagedram[1][0x000];
336	331	m_butasan_txbackram  = &m_butasan_pagedram[1][0x800];
337	332
338		jal_blend_init(machine(), 1);
339
340	333	save_item(NAME(m_bg_status));
341	334	save_item(NAME(m_flipscreen));
342	335	save_item(NAME(m_palette_intensity));
r244697	r244698
390	383	{
391	384	UINT8 lo = m_paletteram[lo_offs];
392	385	UINT8 hi = m_paletteram[hi_offs];
393		jal_blend_set(color, hi & 0x0f);
	386	m_blend->set(color, hi & 0x0f);
394	387	m_palette->set_pen_color(color, pal4bit(lo >> 4), pal4bit(lo), pal4bit(hi >> 4));
395	388	}
396	389
r244697	r244698
426	419	rgb = rgb_t(r,g,b);
427	420	}
428	421
429		rgb = jal_blend_func(rgb,irgb,ix);
	422	rgb = m_blend->func(rgb,irgb,ix);
430	423
431	424	m_palette->set_pen_color(color,rgb);
432	425	}
r244697	r244698
832	825	}
833	826
834	827	if (priority != pri)
835		jal_blend_drawgfx(m_palette,
	828	m_blend->drawgfx(m_palette,
836	829	bitmap,cliprect,m_gfxdecode->gfx(0),
837	830	tile,
838	831	color,
r244697	r244698
956	949	flipy = !flipy;
957	950	}
958	951
959		jal_blend_drawgfx(m_palette,
	952	m_blend->drawgfx(m_palette,
960	953	bitmap,cliprect,m_gfxdecode->gfx(0),
961	954	tile,
962	955	color,
r244697	r244698
1004	997
1005	998	if ((offs >= 0x100 && offs <= 0x2ff) || (offs >= 0x400 && offs <= 0x57f))
1006	999	{
1007		jal_blend_drawgfx(m_palette,
	1000	m_blend->drawgfx(m_palette,
1008	1001	bitmap,cliprect,m_gfxdecode->gfx(0),
1009	1002	tile,
1010	1003	color,
r244697	r244698
1018	1011	{
1019	1012	td = (fx) ? (1 - i) : i;
1020	1013
1021		jal_blend_drawgfx(m_palette,
	1014	m_blend->drawgfx(m_palette,
1022	1015	bitmap,cliprect,m_gfxdecode->gfx(0),
1023	1016	tile + td,
1024	1017	color,
r244697	r244698
1038	1031	else
1039	1032	td = (fx) ? (i * 2) + 1 - j : i * 2 + j;
1040	1033
1041		jal_blend_drawgfx(m_palette,
	1034	m_blend->drawgfx(m_palette,
1042	1035	bitmap,cliprect,m_gfxdecode->gfx(0),
1043	1036	tile + td,
1044	1037	color,
r244697	r244698
1059	1052	else
1060	1053	td = (fx) ? (i * 4) + 3 - j : i * 4 + j;
1061	1054
1062		jal_blend_drawgfx(m_palette,
	1055	m_blend->drawgfx(m_palette,
1063	1056	bitmap,cliprect,m_gfxdecode->gfx(0),
1064	1057	tile + td,
1065	1058	color,

trunk/src/mame/video/jalblend.c

r244697	r244698
14	14	#include "emu.h"
15	15	#include "jalblend.h"
16	16
	17	/*****************************************************************************
	18	DEVICE INTERFACE
	19	*****************************************************************************/
17	20
18		/* each palette entry contains a fourth 'alpha' value */
19		static UINT8 *jal_blend_table;
20	21
21	22
22		static void jal_blend_reset(running_machine &machine)
	23	const device_type JALECO_BLEND = &device_creator<jaleco_blend_device>;
	24
	25	jaleco_blend_device::jaleco_blend_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	26	: device_t(mconfig, JALECO_BLEND, "Jaleco Blending Device", tag, owner, clock, "jaleco_blend", __FILE__),
	27	m_table(NULL)
23	28	{
24		memset(jal_blend_table, 0, 0xc00);
25	29	}
26	30
27		void jal_blend_init(running_machine &machine, int enable)
	31	//-------------------------------------------------
	32	//  device_start - device-specific startup
	33	//-------------------------------------------------
	34
	35	void jaleco_blend_device::device_start()
28	36	{
29		if (enable)
30		{
31		jal_blend_table = auto_alloc_array_clear(machine, UINT8, 0xc00);
32		machine.add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(FUNC(jal_blend_reset), &machine));
33		machine.save().save_pointer(NAME(jal_blend_table), 0xc00);
34		}
35		else
36		{
37		jal_blend_table = NULL;
38		}
	37	m_table = auto_alloc_array_clear(machine(), UINT8, 0xc00);
	38
	39	save_pointer(NAME(m_table), 0xc00);
39	40	}
40	41
41		void jal_blend_set(int color, UINT8 val)
	42	//-------------------------------------------------
	43	//  device_reset - device-specific startup
	44	//-------------------------------------------------
	45
	46	void jaleco_blend_device::device_reset()
42	47	{
43		if (jal_blend_table) jal_blend_table[color] = val;
	48	memset(m_table, 0, 0xc00);
44	49	}
45	50
	51	void jaleco_blend_device::set(int color, UINT8 val)
	52	{
	53	m_table[color] = val;
	54	}
	55
46	56	/*
47	57	* 'Alpha' Format
48	58	* ------------------
r244697	r244698
56	66	*/
57	67
58	68	/* basically an add/subtract function with clamping */
59		rgb_t jal_blend_func(rgb_t dest, rgb_t addMe, UINT8 alpha)
	69	rgb_t jaleco_blend_device::func(rgb_t dest, rgb_t addMe, UINT8 alpha)
60	70	{
61	71	int r, g, b;
62	72	int ir, ig, ib;
r244697	r244698
86	96	}
87	97
88	98	template<class _BitmapClass>
89		void jal_blend_drawgfx_common(palette_device &palette,_BitmapClass &dest_bmp,const rectangle &clip,gfx_element *gfx,
	99	void jaleco_blend_device::drawgfx_common(palette_device &palette,_BitmapClass &dest_bmp,const rectangle &clip,gfx_element *gfx,
90	100	UINT32 code,UINT32 color,int flipx,int flipy,int offsx,int offsy,
91	101	int transparent_color)
92	102	{
93		if (jal_blend_table == NULL)
94		{
95		gfx->transpen(dest_bmp,clip,code,color,flipx,flipy,offsx,offsy,transparent_color);
96		return;
97		}
98
99	103	/* Start drawing */
100		if (gfx)
101		{
102		const pen_t *pal = &palette.pen(gfx->colorbase() + gfx->granularity() * (color % gfx->colors()));
103		const UINT8 *alpha = &jal_blend_table[gfx->granularity() * (color % gfx->colors())];
104		const UINT8 *source_base = gfx->get_data(code % gfx->elements());
105		int x_index_base, y_index, sx, sy, ex, ey;
106		int xinc, yinc;
	104	const pen_t *pal = &palette.pen(gfx->colorbase() + gfx->granularity() * (color % gfx->colors()));
	105	const UINT8 *alpha = &m_table[gfx->granularity() * (color % gfx->colors())];
	106	const UINT8 *source_base = gfx->get_data(code % gfx->elements());
	107	int x_index_base, y_index, sx, sy, ex, ey;
	108	int xinc, yinc;
107	109
108		xinc = flipx ? -1 : 1;
109		yinc = flipy ? -1 : 1;
	110	xinc = flipx ? -1 : 1;
	111	yinc = flipy ? -1 : 1;
110	112
111		x_index_base = flipx ? gfx->width()-1 : 0;
112		y_index = flipy ? gfx->height()-1 : 0;
	113	x_index_base = flipx ? gfx->width()-1 : 0;
	114	y_index = flipy ? gfx->height()-1 : 0;
113	115
114		// start coordinates
115		sx = offsx;
116		sy = offsy;
	116	// start coordinates
	117	sx = offsx;
	118	sy = offsy;
117	119
118		// end coordinates
119		ex = sx + gfx->width();
120		ey = sy + gfx->height();
	120	// end coordinates
	121	ex = sx + gfx->width();
	122	ey = sy + gfx->height();
121	123
122		if (sx < clip.min_x)
123		{ // clip left
124		int pixels = clip.min_x-sx;
125		sx += pixels;
126		x_index_base += xinc*pixels;
127		}
128		if (sy < clip.min_y)
129		{ // clip top
130		int pixels = clip.min_y-sy;
131		sy += pixels;
132		y_index += yinc*pixels;
133		}
134		// NS 980211 - fixed incorrect clipping
135		if (ex > clip.max_x+1)
136		{ // clip right
137		ex = clip.max_x+1;
138		}
139		if (ey > clip.max_y+1)
140		{ // clip bottom
141		ey = clip.max_y+1;
142		}
	124	if (sx < clip.min_x)
	125	{ // clip left
	126	int pixels = clip.min_x-sx;
	127	sx += pixels;
	128	x_index_base += xinc*pixels;
	129	}
	130	if (sy < clip.min_y)
	131	{ // clip top
	132	int pixels = clip.min_y-sy;
	133	sy += pixels;
	134	y_index += yinc*pixels;
	135	}
	136	// NS 980211 - fixed incorrect clipping
	137	if (ex > clip.max_x+1)
	138	{ // clip right
	139	ex = clip.max_x+1;
	140	}
	141	if (ey > clip.max_y+1)
	142	{ // clip bottom
	143	ey = clip.max_y+1;
	144	}
143	145
144		if (ex > sx)
145		{ // skip if inner loop doesn't draw anything
146		int x, y;
	146	if (ex > sx)
	147	{ // skip if inner loop doesn't draw anything
	148	int x, y;
147	149
148		// taken from case 7: TRANSPARENCY_ALPHARANGE
149		for (y = sy; y < ey; y++)
	150	// taken from case 7: TRANSPARENCY_ALPHARANGE
	151	for (y = sy; y < ey; y++)
	152	{
	153	const UINT8 *source = source_base + y_index*gfx->rowbytes();
	154	typename _BitmapClass::pixel_t *dest = &dest_bmp.pix(y);
	155	int x_index = x_index_base;
	156	for (x = sx; x < ex; x++)
150	157	{
151		const UINT8 *source = source_base + y_index*gfx->rowbytes();
152		typename _BitmapClass::pixel_t *dest = &dest_bmp.pix(y);
153		int x_index = x_index_base;
154		for (x = sx; x < ex; x++)
	158	int c = source[x_index];
	159	if (c != transparent_color)
155	160	{
156		int c = source[x_index];
157		if (c != transparent_color)
	161	if (alpha[c] & 8)
158	162	{
159		if (alpha[c] & 8)
160		{
161		// Comp with clamp
162		dest[x] = jal_blend_func(dest[x], pal[c], alpha[c]);
163		}
164		else
165		{
166		// Skip the costly alpha step altogether
167		dest[x] = pal[c];
168		}
	163	// Comp with clamp
	164	dest[x] = jaleco_blend_device::func(dest[x], pal[c], alpha[c]);
169	165	}
170		x_index += xinc;
	166	else
	167	{
	168	// Skip the costly alpha step altogether
	169	dest[x] = pal[c];
	170	}
171	171	}
172		y_index += yinc;
	172	x_index += xinc;
173	173	}
	174	y_index += yinc;
174	175	}
175	176	}
176	177	}
177	178
178		void jal_blend_drawgfx(palette_device &palette,bitmap_ind16 &dest_bmp,const rectangle &clip,gfx_element *gfx,
	179	void jaleco_blend_device::drawgfx(palette_device &palette,bitmap_ind16 &dest_bmp,const rectangle &clip,gfx_element *gfx,
179	180	UINT32 code,UINT32 color,int flipx,int flipy,int offsx,int offsy,
180	181	int transparent_color)
181		{ jal_blend_drawgfx_common(palette,dest_bmp, clip, gfx, code, color, flipx, flipy, offsx, offsy, transparent_color); }
182		void jal_blend_drawgfx(palette_device &palette,bitmap_rgb32 &dest_bmp,const rectangle &clip,gfx_element *gfx,
	182	{ jaleco_blend_device::drawgfx_common(palette,dest_bmp, clip, gfx, code, color, flipx, flipy, offsx, offsy, transparent_color); }
	183	void jaleco_blend_device::drawgfx(palette_device &palette,bitmap_rgb32 &dest_bmp,const rectangle &clip,gfx_element *gfx,
183	184	UINT32 code,UINT32 color,int flipx,int flipy,int offsx,int offsy,
184	185	int transparent_color)
185		{ jal_blend_drawgfx_common(palette,dest_bmp, clip, gfx, code, color, flipx, flipy, offsx, offsy, transparent_color); }
	186	{ jaleco_blend_device::drawgfx_common(palette,dest_bmp, clip, gfx, code, color, flipx, flipy, offsx, offsy, transparent_color); }

trunk/src/mame/video/jalblend.h

r244697	r244698
1		void jal_blend_init(running_machine &machine, int enable);
2		void jal_blend_set(int color, UINT8 val);
3
4		rgb_t jal_blend_func(rgb_t dest, rgb_t addMe, UINT8 alpha);
5		void jal_blend_drawgfx(palette_device &palette,bitmap_ind16 &dest_bmp,const rectangle &clip,gfx_element *gfx,
	1	class jaleco_blend_device : public device_t
	2	{
	3	public:
	4	jaleco_blend_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	5	~jaleco_blend_device() {}
	6
	7	void set(int color, UINT8 val);
	8	rgb_t func(rgb_t dest, rgb_t addMe, UINT8 alpha);
	9	void drawgfx(palette_device &palette,bitmap_ind16 &dest_bmp,const rectangle &clip,gfx_element *gfx,
6	10	UINT32 code,UINT32 color,int flipx,int flipy,int offsx,int offsy,
7	11	int transparent_color);
8		void jal_blend_drawgfx(palette_device &palette,bitmap_rgb32 &dest_bmp,const rectangle &clip,gfx_element *gfx,
	12	void drawgfx(palette_device &palette,bitmap_rgb32 &dest_bmp,const rectangle &clip,gfx_element *gfx,
9	13	UINT32 code,UINT32 color,int flipx,int flipy,int offsx,int offsy,
10	14	int transparent_color);
	15
	16	protected:
	17	// device-level overrides
	18	virtual void device_start();
	19	virtual void device_reset();
	20
	21	private:
	22	/* each palette entry contains a fourth 'alpha' value */
	23	UINT8 *m_table;
	24
	25	template<class _BitmapClass>
	26	void drawgfx_common(palette_device &palette,_BitmapClass &dest_bmp,const rectangle &clip,gfx_element *gfx,
	27	UINT32 code,UINT32 color,int flipx,int flipy,int offsx,int offsy,
	28	int transparent_color);
	29	};
	30
	31	extern const device_type JALECO_BLEND;
		No newline at end of file

trunk/src/mame/video/psychic5.c

r244697	r244698
7	7	***************************************************************************/
8	8
9	9	#include "emu.h"
10		#include "video/jalblend.h"
11	10	#include "includes/psychic5.h"
12	11
13	12
r244697	r244698
25	24	UINT8 hi = palram[(offset) | 1];
26	25
27	26	int color = offset >> 1;
28
29		jal_blend_set(palbase + color, hi & 0x0f);
	27
	28	if (m_blend)
	29	m_blend->set(palbase + color, hi & 0x0f);
	30
30	31	m_palette->set_pen_color(palbase + color, pal4bit(lo >> 4), pal4bit(lo), pal4bit(hi >> 4));
31	32	}
32	33
r244697	r244698
56	57	{
57	58	UINT8 val = (r + g + b) / 3;        /* Grey */
58	59	/* Just leave plain grey */
59		m_palette->set_pen_color(color,jal_blend_func(rgb_t(val,val,val),irgb,ix));
	60	m_palette->set_pen_color(color,m_blend->func(rgb_t(val,val,val),irgb,ix));
60	61	}
61	62	else
62	63	{
r244697	r244698
64	65	if (!(m_title_screen & 1))
65	66	{
66	67	/* Leave the world as-is */
67		m_palette->set_pen_color(color,jal_blend_func(rgb_t(r,g,b),irgb,ix));
	68	m_palette->set_pen_color(color,m_blend->func(rgb_t(r,g,b),irgb,ix));
68	69	}
69	70	}
70	71	}
r244697	r244698
191	192	m_bg_tilemap = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(psychic5_state::get_bg_tile_info),this), TILEMAP_SCAN_COLS, 16, 16, 64, 32);
192	193	m_fg_tilemap = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(psychic5_state::get_fg_tile_info),this), TILEMAP_SCAN_COLS,  8,  8, 32, 32);
193	194	m_fg_tilemap->set_transparent_pen(15);
194		jal_blend_init(machine(), 1);
195	195
196	196	save_item(NAME(m_title_screen));
197	197
r244697	r244698
204	204	m_bg_tilemap = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(psychic5_state::get_bg_tile_info),this), TILEMAP_SCAN_COLS, 16, 16, 128, 32);
205	205	m_fg_tilemap = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(psychic5_state::get_fg_tile_info),this), TILEMAP_SCAN_COLS,  8,  8,  32, 32);
206	206	m_fg_tilemap->set_transparent_pen(15);
207		jal_blend_init(machine(), 0);
208	207
209	208	save_item(NAME(m_bombsa_unknown));
210	209	}
r244697	r244698
223	222	Screen refresh
224	223	***************************************************************************/
225	224
226		#define DRAW_SPRITE(code, sx, sy) jal_blend_drawgfx(m_palette, bitmap, cliprect, m_gfxdecode->gfx(0), code, color, flipx, flipy, sx, sy, 15);
	225	#define DRAW_SPRITE(code, sx, sy) \
	226	if (m_blend) \
	227	m_blend->drawgfx(m_palette, bitmap, cliprect, m_gfxdecode->gfx(0), code, color, flipx, flipy, sx, sy, 15); \
	228	else \
	229	m_gfxdecode->gfx(0)->transpen(bitmap, cliprect, code, color, flipx, flipy, sx, sy, 15);
227	230
228	231	void psychic5_state::draw_sprites(bitmap_rgb32 &bitmap, const rectangle &cliprect)
229	232	{

https://github.com/mamedev/mame/commit/e166b8f2a41e2df6cbecea1b80dc4eca2abb8333

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team