Previous

199869 Revisions

Next

r20747 Tuesday 5th February, 2013 at 15:23:44 UTC by Miodrag Milanović
Modernization of drivers part 2 (no whatsnew)

[src/mame/drivers]	cabal.c ccastles.c cdi.c centiped.c cischeat.c cloud9.c compgolf.c cps3.c crbaloon.c crospang.c crshrace.c cvs.c galaxia.c
[src/mame/includes]	cabal.h canyon.h capbowl.h carpolo.h cbasebal.h cbuster.h ccastles.h cchasm.h cclimber.h cdi.h centiped.h chaknpop.h champbas.h changela.h cheekyms.h circus.h circusc.h cischeat.h citycon.h cloak.h cloud9.h clshroad.h cninja.h combatsc.h commando.h compgolf.h contra.h cop01.h cosmic.h cps3.h crbaloon.h crgolf.h crospang.h crshrace.h cvs.h cyberbal.h galaxia.h
[src/mame/machine]	carpolo.c cclimber.c chaknpop.c
[src/mame/video]	cabal.c canyon.c capbowl.c carpolo.c cbasebal.c cbuster.c ccastles.c cchasm.c cclimber.c centiped.c chaknpop.c champbas.c changela.c cheekyms.c circus.c circusc.c cischeat.c citycon.c cloak.c cloud9.c clshroad.c cninja.c combatsc.c commando.c compgolf.c contra.c cop01.c cosmic.c crbaloon.c crgolf.c crshrace.c cvs.c cyberbal.c galaxia.c

trunk/src/mame/machine/carpolo.c

r20746	r20747
94	94	}
95	95
96	96
97		void carpolo_generate_ball_screen_interrupt(running_machine &machine, UINT8 cause)
	97	void carpolo_state::carpolo_generate_ball_screen_interrupt(UINT8 cause)
98	98	{
99		carpolo_state *state = machine.driver_data<carpolo_state>();
100		state->m_ball_screen_collision_cause = cause;
	99	m_ball_screen_collision_cause = cause;
101	100
102		ttl74148_input_line_w(state->m_ttl74148_3s, BALL_SCREEN_PRIORITY_LINE, 0);
103		ttl74148_update(state->m_ttl74148_3s);
	101	ttl74148_input_line_w(m_ttl74148_3s, BALL_SCREEN_PRIORITY_LINE, 0);
	102	ttl74148_update(m_ttl74148_3s);
104	103	}
105	104
106		void carpolo_generate_car_car_interrupt(running_machine &machine, int car1, int car2)
	105	void carpolo_state::carpolo_generate_car_car_interrupt(int car1, int car2)
107	106	{
108		carpolo_state *state = machine.driver_data<carpolo_state>();
109		state->m_car_car_collision_cause = ~((1 << (3 - car1)) | (1 << (3 - car2)));
	107	m_car_car_collision_cause = ~((1 << (3 - car1)) | (1 << (3 - car2)));
110	108
111		ttl74148_input_line_w(state->m_ttl74148_3s, CAR_CAR_PRIORITY_LINE, 0);
112		ttl74148_update(state->m_ttl74148_3s);
	109	ttl74148_input_line_w(m_ttl74148_3s, CAR_CAR_PRIORITY_LINE, 0);
	110	ttl74148_update(m_ttl74148_3s);
113	111	}
114	112
115		void carpolo_generate_car_goal_interrupt(running_machine &machine, int car, int right_goal)
	113	void carpolo_state::carpolo_generate_car_goal_interrupt(int car, int right_goal)
116	114	{
117		carpolo_state *state = machine.driver_data<carpolo_state>();
118		state->m_car_goal_collision_cause = car | (right_goal ? 0x08 : 0x00);
	115	m_car_goal_collision_cause = car | (right_goal ? 0x08 : 0x00);
119	116
120		ttl74148_input_line_w(state->m_ttl74148_3s, CAR_GOAL_PRIORITY_LINE, 0);
121		ttl74148_update(state->m_ttl74148_3s);
	117	ttl74148_input_line_w(m_ttl74148_3s, CAR_GOAL_PRIORITY_LINE, 0);
	118	ttl74148_update(m_ttl74148_3s);
122	119	}
123	120
124		void carpolo_generate_car_ball_interrupt(running_machine &machine, int car, int car_x, int car_y)
	121	void carpolo_state::carpolo_generate_car_ball_interrupt(int car, int car_x, int car_y)
125	122	{
126		carpolo_state *state = machine.driver_data<carpolo_state>();
127		state->m_car_ball_collision_cause = car;
128		state->m_car_ball_collision_x = car_x;
129		state->m_car_ball_collision_y = car_y;
	123	m_car_ball_collision_cause = car;
	124	m_car_ball_collision_x = car_x;
	125	m_car_ball_collision_y = car_y;
130	126
131		state->m_priority_0_extension = CAR_BALL_EXTRA_BITS;
	127	m_priority_0_extension = CAR_BALL_EXTRA_BITS;
132	128
133		ttl74148_input_line_w(state->m_ttl74148_3s, PRI0_PRIORTITY_LINE, 0);
134		ttl74148_update(state->m_ttl74148_3s);
	129	ttl74148_input_line_w(m_ttl74148_3s, PRI0_PRIORTITY_LINE, 0);
	130	ttl74148_update(m_ttl74148_3s);
135	131	}
136	132
137		void carpolo_generate_car_border_interrupt(running_machine &machine, int car, int horizontal_border)
	133	void carpolo_state::carpolo_generate_car_border_interrupt(int car, int horizontal_border)
138	134	{
139		carpolo_state *state = machine.driver_data<carpolo_state>();
140		state->m_car_border_collision_cause = car | (horizontal_border ? 0x04 : 0x00);
	135	m_car_border_collision_cause = car | (horizontal_border ? 0x04 : 0x00);
141	136
142		state->m_priority_0_extension = CAR_BORDER_EXTRA_BITS;
	137	m_priority_0_extension = CAR_BORDER_EXTRA_BITS;
143	138
144		ttl74148_input_line_w(state->m_ttl74148_3s, PRI0_PRIORTITY_LINE, 0);
145		ttl74148_update(state->m_ttl74148_3s);
	139	ttl74148_input_line_w(m_ttl74148_3s, PRI0_PRIORTITY_LINE, 0);
	140	ttl74148_update(m_ttl74148_3s);
146	141	}
147	142
148	143

trunk/src/mame/machine/chaknpop.c

r20746	r20747
45	45	0x10, 0xfc, 0x3e, 0x01, 0x32, 0x5b, 0x81, 0xc9
46	46	};
47	47
48		static void mcu_update_seed( running_machine &machine, UINT8 data )
	48	void chaknpop_state::mcu_update_seed( UINT8 data )
49	49	{
50		chaknpop_state *state = machine.driver_data<chaknpop_state>();
51	50
52	51	if (!(data & 0x80))
53	52	{
54		state->m_mcu_seed += 0x83;
55		state->m_mcu_seed = (state->m_mcu_seed & 0x80) | (state->m_mcu_seed >> 1);
	53	m_mcu_seed += 0x83;
	54	m_mcu_seed = (m_mcu_seed & 0x80) | (m_mcu_seed >> 1);
56	55	}
57	56
58		state->m_mcu_seed += 0x19;
	57	m_mcu_seed += 0x19;
59	58
60		//logerror("New seed: 0x%02x\n", state->m_mcu_seed);
	59	//logerror("New seed: 0x%02x\n", m_mcu_seed);
61	60	}
62	61
63	62
r20746	r20747
94	93
95	94	if (mcu_command < 0x08)
96	95	{
97		mcu_update_seed(machine(), data);
	96	mcu_update_seed(data);
98	97
99	98	m_mcu_result = mcu_data[m_mcu_select * 8 + mcu_command];
100	99	m_mcu_result -= m_mcu_seed;
101	100
102		mcu_update_seed(machine(), m_mcu_result);
	101	mcu_update_seed(m_mcu_result);
103	102
104	103	logerror("%04x: MCU command 0x%02x, result 0x%02x\n", space.device().safe_pc(), mcu_command, m_mcu_result);
105	104	}
106	105	else if (mcu_command >= 0x28 && mcu_command <= 0x2a)
107	106	{
108		mcu_update_seed(machine(), data);
	107	mcu_update_seed(data);
109	108
110	109	m_mcu_result = m_mcu_ram[0x380 + mcu_command];
111	110	m_mcu_result -= m_mcu_seed;
112	111
113		mcu_update_seed(machine(), m_mcu_result);
	112	mcu_update_seed(m_mcu_result);
114	113
115	114	logerror("%04x: MCU command 0x%02x, result 0x%02x\n", space.device().safe_pc(), mcu_command, m_mcu_result);
116	115	}
117	116	else if (mcu_command < 0x80)
118	117	{
119		mcu_update_seed(machine(), data);
	118	mcu_update_seed(data);
120	119
121	120	if (mcu_command >= 0x40 && mcu_command < 0x60)
122	121	{
r20746	r20747
127	126	}
128	127	else if (mcu_command == 0x9c|| mcu_command == 0xde)
129	128	{
130		mcu_update_seed(machine(), data);
	129	mcu_update_seed(data);
131	130
132	131	logerror("%04x: MCU command 0x%02x\n", space.device().safe_pc(), mcu_command);
133	132	}

trunk/src/mame/machine/cclimber.c

r20746	r20747
4	4	/* set to 1 to fix protection check after bonus round (see notes in pacman.c driver) */
5	5	#define CANNONB_HACK    0
6	6
7		static void cclimber_decode(running_machine &machine, const UINT8 convtable[8][16])
	7	void cclimber_state::cclimber_decode(const UINT8 convtable[8][16])
8	8	{
9		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
10		UINT8 *rom = machine.root_device().memregion("maincpu")->base();
11		UINT8 *decrypt = auto_alloc_array(machine, UINT8, 0x10000);
	9	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
	10	UINT8 *rom = machine().root_device().memregion("maincpu")->base();
	11	UINT8 *decrypt = auto_alloc_array(machine(), UINT8, 0x10000);
12	12	int A;
13	13
14	14	space.set_decrypted_region(0x0000, 0xffff, decrypt);
r20746	r20747
45	45	{   -1,  -1,0x54,0x01,0x15,0x40,0x45,0x41,0x51,0x04,0x50,0x05,0x11,0x44,0x10,0x14 }
46	46	};
47	47
48		cclimber_decode(machine(), convtable);
	48	cclimber_decode(convtable);
49	49	}
50	50
51	51	DRIVER_INIT_MEMBER(cclimber_state,cclimberj)
r20746	r20747
62	62	{ 0x55,0x50,0x15,0x10,0x01,0x04,0x41,0x44,0x45,0x40,0x05,0x00,0x11,0x14,0x51,0x54 },
63	63	};
64	64
65		cclimber_decode(machine(), convtable);
	65	cclimber_decode(convtable);
66	66	}
67	67
68	68	DRIVER_INIT_MEMBER(cclimber_state,ckongb)
r20746	r20747
77	77	}
78	78
79	79	#if CANNONB_HACK
80		static void cannonb_patch(running_machine &machine)
	80	void ::cannonb_patch()
81	81	{
82		UINT8 *rom = machine.root_device().memregion("maincpu")->base();
	82	UINT8 *rom = machine().root_device().memregion("maincpu")->base();
83	83
84	84	rom[0x2ba0] = 0x21;
85	85	rom[0x2ba1] = 0xfb;

trunk/src/mame/includes/capbowl.h

r20746	r20747
43	43	UINT32 screen_update_capbowl(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
44	44	INTERRUPT_GEN_MEMBER(capbowl_interrupt);
45	45	TIMER_CALLBACK_MEMBER(capbowl_update);
	46	inline rgb_t pen_for_pixel( UINT8 *src, UINT8 pix );
46	47	};

trunk/src/mame/includes/compgolf.h

r20746	r20747
42	42	virtual void video_start();
43	43	virtual void palette_init();
44	44	UINT32 screen_update_compgolf(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	45	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	46	void compgolf_expand_bg();
45	47	};

trunk/src/mame/includes/circusc.h

r20746	r20747
60	60	virtual void palette_init();
61	61	UINT32 screen_update_circusc(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
62	62	INTERRUPT_GEN_MEMBER(vblank_irq);
	63	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
63	64	};

trunk/src/mame/includes/cbasebal.h

r20746	r20747
49	49	virtual void machine_reset();
50	50	virtual void video_start();
51	51	UINT32 screen_update_cbasebal(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	52	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
52	53	};

trunk/src/mame/includes/cninja.h

r20746	r20747
79	79	UINT32 screen_update_robocop2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
80	80	UINT32 screen_update_mutantf(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
81	81	TIMER_DEVICE_CALLBACK_MEMBER(interrupt_gen);
	82	void cninjabl_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
82	83	};

trunk/src/mame/includes/cbuster.h

r20746	r20747
49	49	virtual void machine_reset();
50	50	virtual void video_start();
51	51	UINT32 screen_update_twocrude(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	52	void update_24bitcol( int offset );
52	53	};

trunk/src/mame/includes/canyon.h

r20746	r20747
44	44	DECLARE_WRITE8_MEMBER(canyon_explode_w);
45	45	DECLARE_WRITE8_MEMBER(canyon_attract_w);
46	46	DECLARE_WRITE8_MEMBER(canyon_whistle_w);
	47	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	48	void draw_bombs( bitmap_ind16 &bitmap, const rectangle &cliprect );
47	49	};
48	50
49	51

trunk/src/mame/includes/crbaloon.h

r20746	r20747
44	44	DECLARE_WRITE8_MEMBER(crbaloon_audio_set_music_freq);
45	45	DECLARE_WRITE8_MEMBER(crbaloon_audio_set_music_enable);
46	46	DECLARE_WRITE8_MEMBER(crbaloon_audio_set_laugh_enable);
	47	UINT16 crbaloon_get_collision_address();
	48	void crbaloon_set_clear_collision_address(int _crbaloon_collision_address_clear);
	49	void draw_sprite_and_check_collision(bitmap_ind16 &bitmap);
	50	void pc3092_reset(void);
	51	void pc3092_update();
	52	void pc3259_update(void);
47	53	};
48	54
49	55
r20746	r20747
53	59	void crbaloon_audio_set_breath_enable(device_t *sn, int enabled);
54	60	void crbaloon_audio_set_appear_enable(device_t *sn, int enabled);
55	61	MACHINE_CONFIG_EXTERN( crbaloon_audio );
56
57		/*----------- defined in video/crbaloon.c -----------*/
58		UINT16 crbaloon_get_collision_address(running_machine &machine);
59		void crbaloon_set_clear_collision_address(running_machine &machine, int _crbaloon_collision_address_clear);

trunk/src/mame/includes/cischeat.h

r20746	r20747
87	87	TIMER_DEVICE_CALLBACK_MEMBER(bigrun_scanline);
88	88	TIMER_DEVICE_CALLBACK_MEMBER(scudhamm_scanline);
89	89	TIMER_DEVICE_CALLBACK_MEMBER(armchamp2_scanline);
	90	void prepare_shadows(cischeat_state *state);
	91	inline void scrollram_w(address_space &space, offs_t offset, UINT16 data, UINT16 mem_mask, int which);
	92	void create_tilemaps();
	93	void cischeat_draw_road(bitmap_ind16 &bitmap, const rectangle &cliprect, int road_num, int priority1, int priority2, int transparency);
	94	void f1gpstar_draw_road(bitmap_ind16 &bitmap, const rectangle &cliprect, int road_num, int priority1, int priority2, int transparency);
	95	void cischeat_draw_sprites(bitmap_ind16 &bitmap , const rectangle &cliprect, int priority1, int priority2);
	96	void bigrun_draw_sprites(bitmap_ind16 &bitmap , const rectangle &cliprect, int priority1, int priority2);
	97	void cischeat_untangle_sprites(const char *region);
90	98	};

trunk/src/mame/includes/centiped.h

r20746	r20747
80	80	UINT32 screen_update_milliped(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
81	81	UINT32 screen_update_warlords(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
82	82	TIMER_DEVICE_CALLBACK_MEMBER(generate_interrupt);
	83	void init_penmask();
	84	void init_common();
	85	void milliped_set_color(offs_t offset, UINT8 data);
	86	inline int read_trackball(int idx, int switch_port);
83	87	};

trunk/src/mame/includes/galaxia.h

r20746	r20747
29	29	UINT32 screen_update_galaxia(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
30	30	UINT32 screen_update_astrowar(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
31	31	INTERRUPT_GEN_MEMBER(galaxia_interrupt);
	32	void init_common();
32	33	};

trunk/src/mame/includes/crgolf.h

r20746	r20747
56	56	UINT32 screen_update_crgolf(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
57	57	TIMER_CALLBACK_MEMBER(main_to_sound_callback);
58	58	TIMER_CALLBACK_MEMBER(sound_to_main_callback);
	59	void get_pens( pen_t *pens );
59	60	};
60	61
61	62	/*----------- defined in video/crgolf.c -----------*/

trunk/src/mame/includes/commando.h

r20746	r20747
48	48	virtual void video_start();
49	49	UINT32 screen_update_commando(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
50	50	INTERRUPT_GEN_MEMBER(commando_interrupt);
	51	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
51	52	};

trunk/src/mame/includes/cabal.h

r20746	r20747
35	35	virtual void video_start();
36	36	DECLARE_MACHINE_RESET(cabalbl);
37	37	UINT32 screen_update_cabal(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	38	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
	39	void seibu_sound_bootleg(const char *cpu,int length);
38	40	};

trunk/src/mame/includes/cheekyms.h

r20746	r20747
37	37	virtual void palette_init();
38	38	UINT32 screen_update_cheekyms(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
39	39	INTERRUPT_GEN_MEMBER(vblank_irq);
	40	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx, int flip );
40	41	};

trunk/src/mame/includes/cdi.h

r20746	r20747
68	68	DECLARE_MACHINE_RESET(quizrr42);
69	69	UINT32 screen_update_cdimono1(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
70	70	UINT32 screen_update_cdimono1_lcd(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	71	INLINE void verboselog(int n_level, const char *s_fmt, ...);
71	72	};
72	73
73	74	/*----------- debug defines -----------*/

trunk/src/mame/includes/circus.h

r20746	r20747
42	42	UINT32 screen_update_crash(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
43	43	UINT32 screen_update_ripcord(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
44	44	TIMER_DEVICE_CALLBACK_MEMBER(crash_scanline);
	45	void draw_line( bitmap_ind16 &bitmap, const rectangle &cliprect, int x1, int y1, int x2, int y2, int dotted );
	46	void draw_sprite_collision( bitmap_ind16 &bitmap, const rectangle &cliprect );
	47	void circus_draw_fg( bitmap_ind16 &bitmap, const rectangle &cliprect );
	48	void robotbwl_draw_box( bitmap_ind16 &bitmap, const rectangle &cliprect, int x, int y );
	49	void robotbwl_draw_scoreboard( bitmap_ind16 &bitmap, const rectangle &cliprect );
	50	void robotbwl_draw_bowling_alley( bitmap_ind16 &bitmap, const rectangle &cliprect );
	51	void robotbwl_draw_ball( bitmap_ind16 &bitmap, const rectangle &cliprect );
	52	void crash_draw_car( bitmap_ind16 &bitmap, const rectangle &cliprect );
45	53	};
46	54	/*----------- defined in audio/circus.c -----------*/
47	55

trunk/src/mame/includes/cloud9.h

r20746	r20747
60	60	virtual void video_start();
61	61	UINT32 screen_update_cloud9(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
62	62	TIMER_CALLBACK_MEMBER(clock_irq);
	63	inline void cloud9_write_vram( UINT16 addr, UINT8 data, UINT8 bitmd, UINT8 pixba );
	64	inline void bitmode_autoinc(  );
	65	inline void schedule_next_irq(int curscanline);
63	66	};

trunk/src/mame/includes/cyberbal.h

r20746	r20747
83	83	void cyberbal_sound_reset();
84	84	UINT32 update_one_screen(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int index);
85	85	void update_sound_68k_interrupts();
	86	inline void set_palette_entry(int entry, UINT16 value);
86	87	};

trunk/src/mame/includes/cloak.h

r20746	r20747
41	41	TILE_GET_INFO_MEMBER(get_bg_tile_info);
42	42	virtual void video_start();
43	43	UINT32 screen_update_cloak(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	44	void set_pens();
	45	void draw_bitmap(bitmap_ind16 &bitmap, const rectangle &cliprect);
	46	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
44	47	};

trunk/src/mame/includes/combatsc.h

r20746	r20747
81	81	DECLARE_PALETTE_INIT(combatscb);
82	82	UINT32 screen_update_combatsc(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
83	83	UINT32 screen_update_combatscb(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	84	void set_pens(  );
	85	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, const UINT8 *source, int circuit, UINT32 pri_mask );
	86	void bootleg_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, const UINT8 *source, int circuit );
84	87	};

trunk/src/mame/includes/contra.h

r20746	r20747
62	62	virtual void palette_init();
63	63	UINT32 screen_update_contra(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
64	64	INTERRUPT_GEN_MEMBER(contra_interrupt);
	65	void set_pens(  );
	66	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int bank );
65	67	};

trunk/src/mame/includes/cps3.h

r20746	r20747
108	108	UINT32 screen_update_cps3(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
109	109	INTERRUPT_GEN_MEMBER(cps3_vbl_interrupt);
110	110	INTERRUPT_GEN_MEMBER(cps3_other_interrupt);
	111	UINT16 rotate_left(UINT16 value, int n);
	112	UINT16 rotxor(UINT16 val, UINT16 xorval);
	113	UINT32 cps3_mask(UINT32 address, UINT32 key1, UINT32 key2);
	114	void cps3_decrypt_bios();
	115	void init_common(UINT32 key1, UINT32 key2, int altEncryption);
	116	void cps3_set_mame_colours(int colournum, UINT16 data, UINT32 fadeval);
	117	void cps3_draw_tilemapsprite_line(int tmnum, int drawline, bitmap_rgb32 &bitmap, const rectangle &cliprect );
	118	UINT32 cps3_flashmain_r(address_space &space, int which, UINT32 offset, UINT32 mem_mask);
	119	void cps3_flashmain_w(int which, UINT32 offset, UINT32 data, UINT32 mem_mask);
	120	UINT32 process_byte( UINT8 real_byte, UINT32 destination, int max_length );
	121	void cps3_do_char_dma( UINT32 real_source, UINT32 real_destination, UINT32 real_length );
	122	UINT32 ProcessByte8(UINT8 b,UINT32 dst_offset);
	123	void cps3_do_alt_char_dma( UINT32 src, UINT32 real_dest, UINT32 real_length );
	124	void cps3_process_character_dma(UINT32 address);
	125	void copy_from_nvram();
	126	inline void cps3_drawgfxzoom(bitmap_rgb32 &dest_bmp,const rectangle &clip,gfx_element *gfx,
	127	unsigned int code,unsigned int color,int flipx,int flipy,int sx,int sy,
	128	int transparency,int transparent_color,
	129	int scalex, int scaley,bitmap_ind8 *pri_buffer,UINT32 pri_mask);
	130
111	131	};
112	132
113	133

trunk/src/mame/includes/cvs.h

r20746	r20747
107	107	UINT32 screen_update_cvs(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
108	108	INTERRUPT_GEN_MEMBER(cvs_main_cpu_interrupt);
109	109	TIMER_CALLBACK_MEMBER(cvs_393hz_timer_cb);
	110	void set_pens(  );
	111	void cvs_scroll_stars(  );
	112	void cvs_init_stars(  );
	113	void cvs_update_stars(bitmap_ind16 &bitmap, const rectangle &cliprect, const pen_t star_pen, bool update_always);
	114	void start_393hz_timer();
110	115	};
111
112		/*----------- defined in video/cvs.c -----------*/
113		void cvs_init_stars( running_machine &machine );
114		void cvs_scroll_stars( running_machine &machine );
115		void cvs_update_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, const pen_t star_pen, bool update_always);

trunk/src/mame/includes/champbas.h

r20746	r20747
65	65	void screen_eof_champbas(screen_device &screen, bool state);
66	66	INTERRUPT_GEN_MEMBER(vblank_irq);
67	67	TIMER_CALLBACK_MEMBER(exctsccr_fm_callback);
	68	void champbas_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	69	void exctsccr_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
68	70	};

trunk/src/mame/includes/crshrace.h

r20746	r20747
58	58	virtual void video_start();
59	59	UINT32 screen_update_crshrace(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
60	60	void screen_eof_crshrace(screen_device &screen, bool state);
	61	void draw_bg( bitmap_ind16 &bitmap, const rectangle &cliprect );
	62	void draw_fg(bitmap_ind16 &bitmap, const rectangle &cliprect);
	63	void crshrace_patch_code( UINT16 offset );
61	64	};

trunk/src/mame/includes/clshroad.h

r20746	r20747
31	31	DECLARE_VIDEO_START(clshroad);
32	32	DECLARE_PALETTE_INIT(clshroad);
33	33	UINT32 screen_update_clshroad(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	34	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
34	35	};

trunk/src/mame/includes/carpolo.h

r20746	r20747
83	83	DECLARE_WRITE_LINE_MEMBER(carpolo_7474_2u_1_q_cb);
84	84	DECLARE_WRITE_LINE_MEMBER(carpolo_7474_2u_2_q_cb);
85	85
	86	void remap_sprite_code(int bank, int code, int *remapped_code, int *flipy);
	87	void normalize_coordinates(int *x1, int *y1, int *x2, int *y2);
	88	int check_sprite_left_goal_collision(int x1, int y1, int code1, int flipy1, int goalpost_only);
	89	int check_sprite_right_goal_collision(int x1, int y1, int code1, int flipy1, int goalpost_only);
	90	int check_sprite_border_collision(UINT8 x1, UINT8 y1, int code1, int flipy1);
	91	void carpolo_generate_ball_screen_interrupt(UINT8 cause);
	92	void carpolo_generate_car_car_interrupt(int car1, int car2);
	93	void carpolo_generate_car_goal_interrupt(int car, int right_goal);
	94	void carpolo_generate_car_ball_interrupt(int car, int car_x, int car_y);
	95	void carpolo_generate_car_border_interrupt(int car, int horizontal_border);
	96	void draw_sprite(bitmap_ind16 &bitmap, const rectangle &cliprect,
	97	UINT8 x, UINT8 y, int bank, int code, int col);
	98	int check_sprite_sprite_collision(int x1, int y1, int code1, int flipy1,
	99	int x2, int y2, int code2, int flipy2,
	100	int *col_x, int *col_y);
	101
86	102	};
87	103
88	104
r20746	r20747
92	108	extern const pia6821_interface carpolo_pia1_intf;
93	109
94	110	void carpolo_74148_3s_cb(device_t *device);
95		void carpolo_generate_car_car_interrupt(running_machine &machine, int car1, int car2);
96		void carpolo_generate_ball_screen_interrupt(running_machine &machine, UINT8 cause);
97		void carpolo_generate_car_goal_interrupt(running_machine &machine, int car, int right_goal);
98		void carpolo_generate_car_ball_interrupt(running_machine &machine, int car, int car_x, int car_y);
99		void carpolo_generate_car_border_interrupt(running_machine &machine, int car, int horizontal_border);

trunk/src/mame/includes/changela.h

r20746	r20747
92	92	INTERRUPT_GEN_MEMBER(chl_mcu_irq);
93	93	TIMER_CALLBACK_MEMBER(changela_scanline_callback);
94	94	TIMER_DEVICE_CALLBACK_MEMBER(changela_scanline);
	95	void draw_obj0( bitmap_ind16 &bitmap, int sy );
	96	void draw_obj1( bitmap_ind16 &bitmap );
	97	void draw_river( bitmap_ind16 &bitmap, int sy );
	98	void draw_tree( bitmap_ind16 &bitmap, int sy, int tree_num );
95	99	};

trunk/src/mame/includes/crospang.h

r20746	r20747
50	50	virtual void machine_reset();
51	51	virtual void video_start();
52	52	UINT32 screen_update_crospang(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	53	void tumblepb_gfx1_rearrange();
53	54	};

trunk/src/mame/includes/cosmic.h

r20746	r20747
76	76	UINT32 screen_update_devzone(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
77	77	UINT32 screen_update_nomnlnd(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
78	78	TIMER_DEVICE_CALLBACK_MEMBER(panic_scanline);
	79	void draw_bitmap( bitmap_ind16 &bitmap, const rectangle &cliprect );
	80	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int color_mask, int extra_sprites );
	81	void cosmica_draw_starfield( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect );
	82	void devzone_draw_grid( bitmap_ind16 &bitmap, const rectangle &cliprect );
	83	void nomnlnd_draw_background( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect );
79	84	};

trunk/src/mame/includes/ccastles.h

r20746	r20747
69	69	virtual void video_start();
70	70	UINT32 screen_update_ccastles(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
71	71	TIMER_CALLBACK_MEMBER(clock_irq);
	72	inline void ccastles_write_vram( UINT16 addr, UINT8 data, UINT8 bitmd, UINT8 pixba );
	73	inline void bitmode_autoinc(  );
	74	inline void schedule_next_irq( int curscanline );
72	75	};

trunk/src/mame/includes/cop01.h

r20746	r20747
47	47	virtual void video_start();
48	48	virtual void palette_init();
49	49	UINT32 screen_update_cop01(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	50	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
50	51	};

trunk/src/mame/includes/cchasm.h

r20746	r20747
35	35	TIMER_CALLBACK_MEMBER(cchasm_refresh_end);
36	36	DECLARE_WRITE_LINE_MEMBER(ctc_timer_1_w);
37	37	DECLARE_WRITE_LINE_MEMBER(ctc_timer_2_w);
	38	void cchasm_refresh ();
38	39	};
39	40
40	41	/*----------- defined in audio/cchasm.c -----------*/

trunk/src/mame/includes/chaknpop.h

r20746	r20747
54	54	virtual void palette_init();
55	55	UINT32 screen_update_chaknpop(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
56	56	void tx_tilemap_mark_all_dirty();
	57	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	58	void draw_bitmap( bitmap_ind16 &bitmap, const rectangle &cliprect );
	59	void mcu_update_seed( UINT8 data );
57	60	};

trunk/src/mame/includes/cclimber.h

r20746	r20747
72	72	UINT32 screen_update_yamato(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
73	73	UINT32 screen_update_toprollr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
74	74	INTERRUPT_GEN_MEMBER(vblank_irq);
	75	void swimmer_set_background_pen();
	76	void draw_playfield(bitmap_ind16 &bitmap, const rectangle &cliprect);
	77	void cclimber_draw_bigsprite(bitmap_ind16 &bitmap, const rectangle &cliprect);
	78	void toprollr_draw_bigsprite(bitmap_ind16 &bitmap, const rectangle &cliprect);
	79	void cclimber_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx);
	80	void toprollr_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx);
	81	void swimmer_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx);
	82	void cclimber_decode(const UINT8 convtable[8][16]);
	83	void cannonb_patch();
75	84	};

trunk/src/mame/includes/citycon.h

r20746	r20747
41	41	virtual void machine_reset();
42	42	virtual void video_start();
43	43	UINT32 screen_update_citycon(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	44	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	45	inline void changecolor_RRRRGGGGBBBBxxxx( int color, int indx );
44	46	};

trunk/src/mame/video/contra.c

r20746	r20747
53	53	}
54	54
55	55
56		static void set_pens( running_machine &machine )
	56	void contra_state::set_pens(  )
57	57	{
58		contra_state *state = machine.driver_data<contra_state>();
59	58	int i;
60	59
61	60	for (i = 0x00; i < 0x100; i += 2)
62	61	{
63		UINT16 data = state->m_paletteram[i] | (state->m_paletteram[i | 1] << 8);
	62	UINT16 data = m_paletteram[i] | (m_paletteram[i | 1] << 8);
64	63
65	64	rgb_t color = MAKE_RGB(pal5bit(data >> 0), pal5bit(data >> 5), pal5bit(data >> 10));
66	65
67		colortable_palette_set_color(machine.colortable, i >> 1, color);
	66	colortable_palette_set_color(machine().colortable, i >> 1, color);
68	67	}
69	68	}
70	69
r20746	r20747
283	282
284	283	***************************************************************************/
285	284
286		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int bank )
	285	void contra_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int bank )
287	286	{
288		contra_state *state = machine.driver_data<contra_state>();
289		device_t *k007121 = bank ? state->m_k007121_2 : state->m_k007121_1;
290		address_space &space = machine.driver_data()->generic_space();
	287	device_t *k007121 = bank ? m_k007121_2 : m_k007121_1;
	288	address_space &space = machine().driver_data()->generic_space();
291	289	int base_color = (k007121_ctrlram_r(k007121, space, 6) & 0x30) * 2;
292	290	const UINT8 *source;
293	291
294	292	if (bank == 0)
295		source = state->m_buffered_spriteram;
	293	source = m_buffered_spriteram;
296	294	else
297		source = state->m_buffered_spriteram_2;
	295	source = m_buffered_spriteram_2;
298	296
299		k007121_sprites_draw(k007121, bitmap, cliprect, machine.gfx[bank], machine.colortable, source, base_color, 40, 0, (UINT32)-1);
	297	k007121_sprites_draw(k007121, bitmap, cliprect, machine().gfx[bank], machine().colortable, source, base_color, 40, 0, (UINT32)-1);
300	298	}
301	299
302	300	UINT32 contra_state::screen_update_contra(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
r20746	r20747
314	312	fg_finalclip &= cliprect;
315	313	tx_finalclip &= cliprect;
316	314
317		set_pens(machine());
	315	set_pens();
318	316
319	317	m_fg_tilemap->set_scrollx(0, ctrl_1_0 - 40);
320	318	m_fg_tilemap->set_scrolly(0, ctrl_1_2);
r20746	r20747
323	321
324	322	m_bg_tilemap->draw(bitmap, bg_finalclip, 0 ,0);
325	323	m_fg_tilemap->draw(bitmap, fg_finalclip, 0 ,0);
326		draw_sprites(machine(),bitmap,cliprect, 0);
327		draw_sprites(machine(),bitmap,cliprect, 1);
	324	draw_sprites(bitmap,cliprect, 0);
	325	draw_sprites(bitmap,cliprect, 1);
328	326	m_tx_tilemap->draw(bitmap, tx_finalclip, 0 ,0);
329	327	return 0;
330	328	}

trunk/src/mame/video/cyberbal.c

r20746	r20747
201	201	*
202	202	*************************************/
203	203
204		INLINE void set_palette_entry(running_machine &machine, int entry, UINT16 value)
	204	inline void cyberbal_state::set_palette_entry(int entry, UINT16 value)
205	205	{
206	206	int r, g, b;
207	207
r20746	r20747
209	209	g = ((value >> 4) & 0x3e) | ((value >> 15) & 1);
210	210	b = ((value << 1) & 0x3e) | ((value >> 15) & 1);
211	211
212		palette_set_color_rgb(machine, entry, pal6bit(r), pal6bit(g), pal6bit(b));
	212	palette_set_color_rgb(machine(), entry, pal6bit(r), pal6bit(g), pal6bit(b));
213	213	}
214	214
215	215
r20746	r20747
223	223	WRITE16_HANDLER(cyberbal_state::paletteram_0_w)
224	224	{
225	225	COMBINE_DATA(&m_paletteram_0[offset]);
226		set_palette_entry(machine(), offset, m_paletteram_0[offset]);
	226	set_palette_entry(offset, m_paletteram_0[offset]);
227	227	}
228	228
229	229	READ16_HANDLER(cyberbal_state::paletteram_0_r)
r20746	r20747
235	235	WRITE16_HANDLER(cyberbal_state::paletteram_1_w)
236	236	{
237	237	COMBINE_DATA(&m_paletteram_1[offset]);
238		set_palette_entry(machine(), offset + 0x800, m_paletteram_1[offset]);
	238	set_palette_entry(offset + 0x800, m_paletteram_1[offset]);
239	239	}
240	240
241	241	READ16_HANDLER(cyberbal_state::paletteram_1_r)

trunk/src/mame/video/cop01.c

r20746	r20747
161	161
162	162	***************************************************************************/
163	163
164		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	164	void cop01_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
165	165	{
166		cop01_state *state = machine.driver_data<cop01_state>();
167	166	int offs, code, attr, sx, sy, flipx, flipy, color;
168	167
169		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 4)
	168	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
170	169	{
171		code = state->m_spriteram[offs + 1];
172		attr = state->m_spriteram[offs + 2];
	170	code = m_spriteram[offs + 1];
	171	attr = m_spriteram[offs + 2];
173	172	/* xxxx---- color
174	173	* ----xx-- flipy,flipx
175	174	* -------x msbx
r20746	r20747
178	177	flipx = attr & 0x04;
179	178	flipy = attr & 0x08;
180	179
181		sx = (state->m_spriteram[offs + 3] - 0x80) + 256 * (attr & 0x01);
182		sy = 240 - state->m_spriteram[offs];
	180	sx = (m_spriteram[offs + 3] - 0x80) + 256 * (attr & 0x01);
	181	sy = 240 - m_spriteram[offs];
183	182
184		if (state->flip_screen())
	183	if (flip_screen())
185	184	{
186	185	sx = 240 - sx;
187	186	sy = 240 - sy;
r20746	r20747
190	189	}
191	190
192	191	if (code & 0x80)
193		code += (state->m_vreg[0] & 0x30) << 3;
	192	code += (m_vreg[0] & 0x30) << 3;
194	193
195		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	194	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
196	195	code,
197	196	color,
198	197	flipx,flipy,
r20746	r20747
207	206	m_bg_tilemap->set_scrolly(0, m_vreg[3]);
208	207
209	208	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
210		draw_sprites(machine(), bitmap, cliprect);
	209	draw_sprites(bitmap, cliprect);
211	210	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 0);
212	211	m_fg_tilemap->draw(bitmap, cliprect, 0, 0 );
213	212	return 0;

trunk/src/mame/video/combatsc.c

r20746	r20747
90	90	}
91	91
92	92
93		static void set_pens( running_machine &machine )
	93	void combatsc_state::set_pens(  )
94	94	{
95		combatsc_state *state = machine.driver_data<combatsc_state>();
96	95	int i;
97	96
98	97	for (i = 0x00; i < 0x100; i += 2)
99	98	{
100		UINT16 data = state->m_paletteram[i] | (state->m_paletteram[i | 1] << 8);
	99	UINT16 data = m_paletteram[i] | (m_paletteram[i | 1] << 8);
101	100
102	101	rgb_t color = MAKE_RGB(pal5bit(data >> 0), pal5bit(data >> 5), pal5bit(data >> 10));
103	102
104		colortable_palette_set_color(machine.colortable, i >> 1, color);
	103	colortable_palette_set_color(machine().colortable, i >> 1, color);
105	104	}
106	105	}
107	106
r20746	r20747
380	379
381	380	***************************************************************************/
382	381
383		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, const UINT8 *source, int circuit, UINT32 pri_mask )
	382	void combatsc_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, const UINT8 *source, int circuit, UINT32 pri_mask )
384	383	{
385		combatsc_state *state = machine.driver_data<combatsc_state>();
386		device_t *k007121 = circuit ? state->m_k007121_2 : state->m_k007121_1;
387		address_space &space = machine.driver_data()->generic_space();
	384	device_t *k007121 = circuit ? m_k007121_2 : m_k007121_1;
	385	address_space &space = machine().driver_data()->generic_space();
388	386	int base_color = (circuit * 4) * 16 + (k007121_ctrlram_r(k007121, space, 6) & 0x10) * 2;
389	387
390		k007121_sprites_draw(k007121, bitmap, cliprect, machine.gfx[circuit], machine.colortable, source, base_color, 0, 0, pri_mask);
	388	k007121_sprites_draw(k007121, bitmap, cliprect, machine().gfx[circuit], machine().colortable, source, base_color, 0, 0, pri_mask);
391	389	}
392	390
393	391
r20746	r20747
395	393	{
396	394	int i;
397	395
398		set_pens(machine());
	396	set_pens();
399	397
400	398	address_space &space = machine().driver_data()->generic_space();
401	399	if (k007121_ctrlram_r(m_k007121_1, space, 1) & 0x02)
r20746	r20747
435	433	m_bg_tilemap[0]->draw(bitmap, cliprect, 1, 2);
436	434
437	435	/* we use the priority buffer so sprites are drawn front to back */
438		draw_sprites(machine(), bitmap, cliprect, m_spriteram[1], 1, 0x0f00);
439		draw_sprites(machine(), bitmap, cliprect, m_spriteram[0], 0, 0x4444);
	436	draw_sprites(bitmap, cliprect, m_spriteram[1], 1, 0x0f00);
	437	draw_sprites(bitmap, cliprect, m_spriteram[0], 0, 0x4444);
440	438	}
441	439	else
442	440	{
r20746	r20747
446	444	m_bg_tilemap[1]->draw(bitmap, cliprect, 0, 8);
447	445
448	446	/* we use the priority buffer so sprites are drawn front to back */
449		draw_sprites(machine(), bitmap, cliprect, m_spriteram[1], 1, 0x0f00);
450		draw_sprites(machine(), bitmap, cliprect, m_spriteram[0], 0, 0x4444);
	447	draw_sprites(bitmap, cliprect, m_spriteram[1], 1, 0x0f00);
	448	draw_sprites(bitmap, cliprect, m_spriteram[0], 0, 0x4444);
451	449	}
452	450
453	451	if (k007121_ctrlram_r(m_k007121_1, space, 1) & 0x08)
r20746	r20747
503	501
504	502	***************************************************************************/
505	503
506		static void bootleg_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, const UINT8 *source, int circuit )
	504	void combatsc_state::bootleg_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, const UINT8 *source, int circuit )
507	505	{
508		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
509		gfx_element *gfx = machine.gfx[circuit + 2];
	506	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
	507	gfx_element *gfx = machine().gfx[circuit + 2];
510	508
511	509	int limit = circuit ? (space.read_byte(0xc2) * 256 + space.read_byte(0xc3)) : (space.read_byte(0xc0) * 256 + space.read_byte(0xc1));
512	510	const UINT8 *finish;
r20746	r20747
536	534	color = (circuit * 4) * 16 + (color >> 4);
537	535
538	536	/*  hacks to select alternate palettes */
539		//          if(state->m_vreg == 0x40 && (attributes & 0x40)) color += 1*16;
540		//          if(state->m_vreg == 0x23 && (attributes & 0x02)) color += 1*16;
541		//          if(state->m_vreg == 0x66 ) color += 2*16;
	537	//          if(m_vreg == 0x40 && (attributes & 0x40)) color += 1*16;
	538	//          if(m_vreg == 0x23 && (attributes & 0x02)) color += 1*16;
	539	//          if(m_vreg == 0x66 ) color += 2*16;
542	540
543	541	drawgfx_transpen(   bitmap, cliprect, gfx,
544	542	number, color,
r20746	r20747
553	551	{
554	552	int i;
555	553
556		set_pens(machine());
	554	set_pens();
557	555
558	556	for (i = 0; i < 32; i++)
559	557	{
r20746	r20747
566	564	if (m_priority == 0)
567	565	{
568	566	m_bg_tilemap[1]->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
569		bootleg_draw_sprites(machine(), bitmap,cliprect, m_page[0], 0);
	567	bootleg_draw_sprites(bitmap,cliprect, m_page[0], 0);
570	568	m_bg_tilemap[0]->draw(bitmap, cliprect, 0 ,0);
571		bootleg_draw_sprites(machine(), bitmap,cliprect, m_page[1], 1);
	569	bootleg_draw_sprites(bitmap,cliprect, m_page[1], 1);
572	570	}
573	571	else
574	572	{
575	573	m_bg_tilemap[0]->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
576		bootleg_draw_sprites(machine(), bitmap,cliprect, m_page[0], 0);
	574	bootleg_draw_sprites(bitmap,cliprect, m_page[0], 0);
577	575	m_bg_tilemap[1]->draw(bitmap, cliprect, 0, 0);
578		bootleg_draw_sprites(machine(), bitmap,cliprect, m_page[1], 1);
	576	bootleg_draw_sprites(bitmap,cliprect, m_page[1], 1);
579	577	}
580	578
581	579	m_textlayer->draw(bitmap, cliprect, 0, 0);

trunk/src/mame/video/cosmic.c

r20746	r20747
248	248	}
249	249
250	250
251		static void draw_bitmap( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	251	void cosmic_state::draw_bitmap( bitmap_ind16 &bitmap, const rectangle &cliprect )
252	252	{
253		cosmic_state *state = machine.driver_data<cosmic_state>();
254	253	offs_t offs;
255	254
256		for (offs = 0; offs < state->m_videoram.bytes(); offs++)
	255	for (offs = 0; offs < m_videoram.bytes(); offs++)
257	256	{
258	257	int i;
259		UINT8 data = state->m_videoram[offs];
	258	UINT8 data = m_videoram[offs];
260	259
261	260	UINT8 x = offs << 3;
262	261	UINT8 y = offs >> 5;
263	262
264		pen_t pen = state->m_map_color(machine, x, y);
	263	pen_t pen = m_map_color(machine(), x, y);
265	264
266	265	for (i = 0; i < 8; i++)
267	266	{
268	267	if (data & 0x80)
269	268	{
270		if (state->flip_screen())
	269	if (flip_screen())
271	270	bitmap.pix16(255-y, 255-x) = pen;
272	271	else
273	272	bitmap.pix16(y, x) = pen;
r20746	r20747
280	279	}
281	280
282	281
283		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int color_mask, int extra_sprites )
	282	void cosmic_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int color_mask, int extra_sprites )
284	283	{
285		cosmic_state *state = machine.driver_data<cosmic_state>();
286	284	int offs;
287	285
288		for (offs = state->m_spriteram.bytes() - 4;offs >= 0;offs -= 4)
	286	for (offs = m_spriteram.bytes() - 4;offs >= 0;offs -= 4)
289	287	{
290		if (state->m_spriteram[offs] != 0)
	288	if (m_spriteram[offs] != 0)
291	289	{
292	290	int code, color;
293	291
294		code  = ~state->m_spriteram[offs] & 0x3f;
295		color = ~state->m_spriteram[offs + 3] & color_mask;
	292	code  = ~m_spriteram[offs] & 0x3f;
	293	color = ~m_spriteram[offs + 3] & color_mask;
296	294
297	295	if (extra_sprites)
298		code |= (state->m_spriteram[offs + 3] & 0x08) << 3;
	296	code |= (m_spriteram[offs + 3] & 0x08) << 3;
299	297
300		if (state->m_spriteram[offs] & 0x80)
	298	if (m_spriteram[offs] & 0x80)
301	299	/* 16x16 sprite */
302		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	300	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
303	301	code, color,
304		0, ~state->m_spriteram[offs] & 0x40,
305		256-state->m_spriteram[offs + 2],state->m_spriteram[offs + 1],0);
	302	0, ~m_spriteram[offs] & 0x40,
	303	256-m_spriteram[offs + 2],m_spriteram[offs + 1],0);
306	304	else
307	305	/* 32x32 sprite */
308		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	306	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
309	307	code >> 2, color,
310		0, ~state->m_spriteram[offs] & 0x40,
311		256-state->m_spriteram[offs + 2],state->m_spriteram[offs + 1],0);
	308	0, ~m_spriteram[offs] & 0x40,
	309	256-m_spriteram[offs + 2],m_spriteram[offs + 1],0);
312	310	}
313	311	}
314	312	}
315	313
316	314
317		static void cosmica_draw_starfield( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect )
	315	void cosmic_state::cosmica_draw_starfield( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect )
318	316	{
319		cosmic_state *state = screen.machine().driver_data<cosmic_state>();
320	317	UINT8 y = 0;
321	318	UINT8 map = 0;
322		UINT8 *PROM = state->memregion("user2")->base();
	319	UINT8 *PROM = memregion("user2")->base();
323	320
324	321	while (1)
325	322	{
r20746	r20747
333	330	UINT8 x1;
334	331	int hc, hb_;
335	332
336		if (state->flip_screen())
	333	if (flip_screen())
337	334	x1 = x - screen.frame_number();
338	335	else
339	336	x1 = x + screen.frame_number();
r20746	r20747
364	361	}
365	362
366	363
367		static void devzone_draw_grid( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	364	void cosmic_state::devzone_draw_grid( bitmap_ind16 &bitmap, const rectangle &cliprect )
368	365	{
369		cosmic_state *state = machine.driver_data<cosmic_state>();
370	366	UINT8 y;
371		UINT8 *horz_PROM = state->memregion("user2")->base();
372		UINT8 *vert_PROM = state->memregion("user3")->base();
	367	UINT8 *horz_PROM = memregion("user2")->base();
	368	UINT8 *vert_PROM = memregion("user3")->base();
373	369	offs_t horz_addr = 0;
374	370
375	371	UINT8 count = 0;
r20746	r20747
405	401	if (!(vert_data & horz_data & 0x80))    /* NAND gate */
406	402	{
407	403	/* blue */
408		if (state->flip_screen())
	404	if (flip_screen())
409	405	bitmap.pix16(255-y, 255-x) = 4;
410	406	else
411	407	bitmap.pix16(y, x) = 4;
r20746	r20747
423	419	}
424	420
425	421
426		static void nomnlnd_draw_background( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect )
	422	void cosmic_state::nomnlnd_draw_background( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect )
427	423	{
428		cosmic_state *state = screen.machine().driver_data<cosmic_state>();
429	424	UINT8 y = 0;
430	425	UINT8 water = screen.frame_number();
431		UINT8 *PROM = state->memregion("user2")->base();
	426	UINT8 *PROM = memregion("user2")->base();
432	427
433	428	/* all positioning is via logic gates:
434	429
r20746	r20747
491	486	if ((!hd_) & hc_ & (!hb_))
492	487	{
493	488	offs_t offs = ((x >> 3) & 0x03) | ((y & 0x1f) << 2) |
494		(state->flip_screen() ? 0x80 : 0);
	489	(flip_screen() ? 0x80 : 0);
495	490
496	491	UINT8 plane1 = PROM[offs         ] << (x & 0x07);
497	492	UINT8 plane2 = PROM[offs | 0x0400] << (x & 0x07);
r20746	r20747
525	520
526	521	if (color != 0)
527	522	{
528		if (state->flip_screen())
	523	if (flip_screen())
529	524	bitmap.pix16(255-y, 255-x) = color;
530	525	else
531	526	bitmap.pix16(y, x) = color;
r20746	r20747
549	544	UINT32 cosmic_state::screen_update_cosmicg(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
550	545	{
551	546	bitmap.fill(0, cliprect);
552		draw_bitmap(machine(), bitmap, cliprect);
	547	draw_bitmap(bitmap, cliprect);
553	548	return 0;
554	549	}
555	550
r20746	r20747
557	552	UINT32 cosmic_state::screen_update_panic(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
558	553	{
559	554	bitmap.fill(0, cliprect);
560		draw_bitmap(machine(), bitmap, cliprect);
561		draw_sprites(machine(), bitmap, cliprect, 0x07, 1);
	555	draw_bitmap(bitmap, cliprect);
	556	draw_sprites(bitmap, cliprect, 0x07, 1);
562	557	return 0;
563	558	}
564	559
r20746	r20747
567	562	{
568	563	bitmap.fill(0, cliprect);
569	564	cosmica_draw_starfield(screen, bitmap, cliprect);
570		draw_bitmap(machine(), bitmap, cliprect);
571		draw_sprites(machine(), bitmap, cliprect, 0x0f, 0);
	565	draw_bitmap(bitmap, cliprect);
	566	draw_sprites(bitmap, cliprect, 0x0f, 0);
572	567	return 0;
573	568	}
574	569
r20746	r20747
576	571	UINT32 cosmic_state::screen_update_magspot(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
577	572	{
578	573	bitmap.fill(0, cliprect);
579		draw_bitmap(machine(), bitmap, cliprect);
580		draw_sprites(machine(), bitmap, cliprect, 0x07, 0);
	574	draw_bitmap(bitmap, cliprect);
	575	draw_sprites(bitmap, cliprect, 0x07, 0);
581	576	return 0;
582	577	}
583	578
r20746	r20747
587	582	bitmap.fill(0, cliprect);
588	583
589	584	if (m_background_enable)
590		devzone_draw_grid(machine(), bitmap, cliprect);
	585	devzone_draw_grid(bitmap, cliprect);
591	586
592		draw_bitmap(machine(), bitmap, cliprect);
593		draw_sprites(machine(), bitmap, cliprect, 0x07, 0);
	587	draw_bitmap(bitmap, cliprect);
	588	draw_sprites(bitmap, cliprect, 0x07, 0);
594	589	return 0;
595	590	}
596	591
r20746	r20747
601	596	have the highest priority */
602	597
603	598	bitmap.fill(0, cliprect);
604		draw_bitmap(machine(), bitmap, cliprect);
605		draw_sprites(machine(), bitmap, cliprect, 0x07, 0);
	599	draw_bitmap(bitmap, cliprect);
	600	draw_sprites(bitmap, cliprect, 0x07, 0);
606	601
607	602	if (m_background_enable)
608	603	nomnlnd_draw_background(screen, bitmap, cliprect);

trunk/src/mame/video/carpolo.c

r20746	r20747
186	186	}
187	187
188	188
189		static void remap_sprite_code(running_machine &machine, int bank, int code, int *remapped_code, int *flipy)
	189	void carpolo_state::remap_sprite_code(int bank, int code, int *remapped_code, int *flipy)
190	190	{
191		UINT8* PROM = machine.root_device().memregion("user1")->base();
	191	UINT8* PROM = machine().root_device().memregion("user1")->base();
192	192
193	193	code = (bank << 4) | code;
194	194	*remapped_code = PROM[code] & 0x0f;
r20746	r20747
196	196	}
197	197
198	198
199		static void draw_sprite(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect,
	199	void carpolo_state::draw_sprite(bitmap_ind16 &bitmap, const rectangle &cliprect,
200	200	UINT8 x, UINT8 y, int bank, int code, int col)
201	201	{
202	202	int remapped_code, flipy;
203	203
204		remap_sprite_code(machine, bank, code, &remapped_code, &flipy);
	204	remap_sprite_code(bank, code, &remapped_code, &flipy);
205	205
206	206	x = 240 - x;
207	207	y = 240 - y;
208	208
209		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	209	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
210	210	remapped_code, col,
211	211	0, flipy,
212	212	x, y,0);
213	213
214	214	/* draw with wrap around */
215		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	215	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
216	216	remapped_code, col,
217	217	0, flipy,
218	218	(INT16)x - 256, y,0);
r20746	r20747
230	230	bitmap.plot_box(0,TOP_BORDER,RIGHT_BORDER+1,BOTTOM_BORDER-TOP_BORDER+1,FIELD_PEN);
231	231
232	232	/* car 1 */
233		draw_sprite(machine(), bitmap, cliprect,
	233	draw_sprite(bitmap, cliprect,
234	234	m_spriteram[0x00], m_spriteram[0x01],
235	235	0, m_spriteram[0x0c] & 0x0f, CAR1_COLOR);
236	236
r20746	r20747
241	241	bitmap.plot_box(RIGHT_BORDER,TOP_BORDER,1,BOTTOM_BORDER-TOP_BORDER+1,LINE_PEN);
242	242
243	243	/* car 4 */
244		draw_sprite(machine(), bitmap, cliprect,
	244	draw_sprite(bitmap, cliprect,
245	245	m_spriteram[0x06], m_spriteram[0x07],
246	246	0, m_spriteram[0x0d] >> 4, CAR4_COLOR);
247	247
248	248	/* car 3 */
249		draw_sprite(machine(), bitmap, cliprect,
	249	draw_sprite(bitmap, cliprect,
250	250	m_spriteram[0x04], m_spriteram[0x05],
251	251	0, m_spriteram[0x0d] & 0x0f, CAR3_COLOR);
252	252
253	253	/* car 2 */
254		draw_sprite(machine(), bitmap, cliprect,
	254	draw_sprite(bitmap, cliprect,
255	255	m_spriteram[0x02], m_spriteram[0x03],
256	256	0, m_spriteram[0x0c] >> 4, CAR2_COLOR);
257	257
258	258	/* ball */
259		draw_sprite(machine(), bitmap, cliprect,
	259	draw_sprite(bitmap, cliprect,
260	260	m_spriteram[0x08], m_spriteram[0x09],
261	261	1, m_spriteram[0x0e] & 0x0f, BALL_COLOR);
262	262
r20746	r20747
281	281	popmessage("WIDE!\n");
282	282
283	283	if (m_spriteram[0x0f] & 0x01)
284		draw_sprite(machine(), bitmap, cliprect,
	284	draw_sprite(bitmap, cliprect,
285	285	m_spriteram[0x0a], m_spriteram[0x0b],
286	286	1, m_spriteram[0x0e] >> 4, SPECIAL_CHAR_COLOR);
287	287
r20746	r20747
311	311	*
312	312	*************************************/
313	313
314		static void normalize_coordinates(int *x1, int *y1, int *x2, int *y2)
	314	void carpolo_state::normalize_coordinates(int *x1, int *y1, int *x2, int *y2)
315	315	{
316	316	if (*x1 < *x2)
317	317	{
r20746	r20747
337	337	}
338	338
339	339
340		static int check_sprite_sprite_collision(running_machine &machine,
341		int x1, int y1, int code1, int flipy1,
	340	int carpolo_state::check_sprite_sprite_collision(int x1, int y1, int code1, int flipy1,
342	341	int x2, int y2, int code2, int flipy2,
343	342	int *col_x, int *col_y)
344	343	{
345		carpolo_state *state = machine.driver_data<carpolo_state>();
346	344	int collided = 0;
347	345
348	346	x1 = 240 - x1;
r20746	r20747
357	355
358	356	normalize_coordinates(&x1, &y1, &x2, &y2);
359	357
360		state->m_sprite_sprite_collision_bitmap1->fill(0);
361		state->m_sprite_sprite_collision_bitmap2->fill(0);
	358	m_sprite_sprite_collision_bitmap1->fill(0);
	359	m_sprite_sprite_collision_bitmap2->fill(0);
362	360
363		drawgfx_opaque(*state->m_sprite_sprite_collision_bitmap1,state->m_sprite_sprite_collision_bitmap1->cliprect(),machine.gfx[0],
	361	drawgfx_opaque(*m_sprite_sprite_collision_bitmap1,m_sprite_sprite_collision_bitmap1->cliprect(),machine().gfx[0],
364	362	code1,0,
365	363	0,flipy1,
366	364	x1,y1);
367	365
368		drawgfx_opaque(*state->m_sprite_sprite_collision_bitmap2,state->m_sprite_sprite_collision_bitmap2->cliprect(),machine.gfx[0],
	366	drawgfx_opaque(*m_sprite_sprite_collision_bitmap2,m_sprite_sprite_collision_bitmap2->cliprect(),machine().gfx[0],
369	367	code2,0,
370	368	0,flipy2,
371	369	x2,y2);
372	370
373	371	for (x = x1; x < x1 + SPRITE_WIDTH; x++)
374	372	for (y = y1; y < y1 + SPRITE_HEIGHT; y++)
375		if ((state->m_sprite_sprite_collision_bitmap1->pix16(y, x) == 1) &&
376		(state->m_sprite_sprite_collision_bitmap2->pix16(y, x) == 1))
	373	if ((m_sprite_sprite_collision_bitmap1->pix16(y, x) == 1) &&
	374	(m_sprite_sprite_collision_bitmap2->pix16(y, x) == 1))
377	375	{
378	376	*col_x = (x1 + x) & 0x0f;
379	377	*col_y = (y1 + y) & 0x0f;
r20746	r20747
390	388
391	389	/* returns 1 for collision with goal post,
392	390	2 for collision with scoring area */
393		static int check_sprite_left_goal_collision(running_machine &machine, int x1, int y1, int code1, int flipy1, int goalpost_only)
	391	int carpolo_state::check_sprite_left_goal_collision(int x1, int y1, int code1, int flipy1, int goalpost_only)
394	392	{
395		carpolo_state *state = machine.driver_data<carpolo_state>();
396	393	int collided = 0;
397	394
398	395	x1 = 240 - x1;
r20746	r20747
411	408
412	409	normalize_coordinates(&x1, &y1, &x2, &y2);
413	410
414		state->m_sprite_goal_collision_bitmap1->fill(0);
415		state->m_sprite_goal_collision_bitmap2->fill(0);
	411	m_sprite_goal_collision_bitmap1->fill(0);
	412	m_sprite_goal_collision_bitmap2->fill(0);
416	413
417		drawgfx_opaque(*state->m_sprite_goal_collision_bitmap1,state->m_sprite_goal_collision_bitmap1->cliprect(),machine.gfx[0],
	414	drawgfx_opaque(*m_sprite_goal_collision_bitmap1,m_sprite_goal_collision_bitmap1->cliprect(),machine().gfx[0],
418	415	code1,0,
419	416	0,flipy1,
420	417	x1,y1);
421	418
422		drawgfxzoom_transpen(*state->m_sprite_goal_collision_bitmap2,state->m_sprite_goal_collision_bitmap2->cliprect(),machine.gfx[1],
	419	drawgfxzoom_transpen(*m_sprite_goal_collision_bitmap2,m_sprite_goal_collision_bitmap2->cliprect(),machine().gfx[1],
423	420	0,0,
424	421	0,0,
425	422	x2,y2,
r20746	r20747
427	424
428	425	for (x = x1; x < x1 + SPRITE_WIDTH; x++)
429	426	for (y = y1; y < y1 + SPRITE_HEIGHT; y++)
430		if (state->m_sprite_goal_collision_bitmap1->pix16(y, x) == 1)
	427	if (m_sprite_goal_collision_bitmap1->pix16(y, x) == 1)
431	428	{
432		pen_t pix = state->m_sprite_goal_collision_bitmap2->pix16(y, x);
	429	pen_t pix = m_sprite_goal_collision_bitmap2->pix16(y, x);
433	430
434	431	if (pix == LEFT_GOAL_PEN)
435	432	{
r20746	r20747
449	446	}
450	447
451	448
452		static int check_sprite_right_goal_collision(running_machine &machine, int x1, int y1, int code1, int flipy1, int goalpost_only)
	449	int carpolo_state::check_sprite_right_goal_collision(int x1, int y1, int code1, int flipy1, int goalpost_only)
453	450	{
454		carpolo_state *state = machine.driver_data<carpolo_state>();
455	451	int collided = 0;
456	452
457	453	x1 = 240 - x1;
r20746	r20747
469	465
470	466	normalize_coordinates(&x1, &y1, &x2, &y2);
471	467
472		state->m_sprite_goal_collision_bitmap1->fill(0);
473		state->m_sprite_goal_collision_bitmap2->fill(0);
	468	m_sprite_goal_collision_bitmap1->fill(0);
	469	m_sprite_goal_collision_bitmap2->fill(0);
474	470
475		drawgfx_opaque(*state->m_sprite_goal_collision_bitmap1,state->m_sprite_goal_collision_bitmap1->cliprect(),machine.gfx[0],
	471	drawgfx_opaque(*m_sprite_goal_collision_bitmap1,m_sprite_goal_collision_bitmap1->cliprect(),machine().gfx[0],
476	472	code1,0,
477	473	0,flipy1,
478	474	x1,y1);
479	475
480		drawgfxzoom_transpen(*state->m_sprite_goal_collision_bitmap2,state->m_sprite_goal_collision_bitmap2->cliprect(),machine.gfx[1],
	476	drawgfxzoom_transpen(*m_sprite_goal_collision_bitmap2,m_sprite_goal_collision_bitmap2->cliprect(),machine().gfx[1],
481	477	0,1,
482	478	1,0,
483	479	x2,y2,
r20746	r20747
485	481
486	482	for (x = x1; x < x1 + SPRITE_WIDTH; x++)
487	483	for (y = y1; y < y1 + SPRITE_HEIGHT; y++)
488		if (state->m_sprite_goal_collision_bitmap1->pix16(y, x) == 1)
	484	if (m_sprite_goal_collision_bitmap1->pix16(y, x) == 1)
489	485	{
490		pen_t pix = state->m_sprite_goal_collision_bitmap2->pix16(y, x);
	486	pen_t pix = m_sprite_goal_collision_bitmap2->pix16(y, x);
491	487
492	488	if (pix == RIGHT_GOAL_PEN)
493	489	{
r20746	r20747
509	505
510	506	/* returns 1 for collision with vertical border,
511	507	2 for collision with horizontal border */
512		static int check_sprite_border_collision(running_machine &machine, UINT8 x1, UINT8 y1, int code1, int flipy1)
	508	int carpolo_state::check_sprite_border_collision(UINT8 x1, UINT8 y1, int code1, int flipy1)
513	509	{
514		carpolo_state *state = machine.driver_data<carpolo_state>();
515	510	UINT8 x,y;
516	511	int collided = 0;
517	512
518	513	x1 = 240 - x1;
519	514	y1 = 240 - y1;
520	515
521		drawgfx_opaque(*state->m_sprite_border_collision_bitmap,state->m_sprite_border_collision_bitmap->cliprect(),machine.gfx[0],
	516	drawgfx_opaque(*m_sprite_border_collision_bitmap,m_sprite_border_collision_bitmap->cliprect(),machine().gfx[0],
522	517	code1,0,
523	518	0,flipy1,
524	519	0,0);
525	520
526	521	for (x = 0; x < SPRITE_WIDTH; x++)
527	522	for (y = 0; y < SPRITE_HEIGHT; y++)
528		if (state->m_sprite_border_collision_bitmap->pix16(y, x) == 1)
	523	if (m_sprite_border_collision_bitmap->pix16(y, x) == 1)
529	524	{
530	525	if (((UINT8)(x1 + x) == LEFT_BORDER) ||
531	526	((UINT8)(x1 + x) == RIGHT_BORDER))
r20746	r20747
562	557
563	558	car1_x = m_spriteram[0x00];
564	559	car1_y = m_spriteram[0x01];
565		remap_sprite_code(machine(), 0, m_spriteram[0x0c] & 0x0f, &car1_code, &car1_flipy);
	560	remap_sprite_code(0, m_spriteram[0x0c] & 0x0f, &car1_code, &car1_flipy);
566	561
567	562	car2_x = m_spriteram[0x02];
568	563	car2_y = m_spriteram[0x03];
569		remap_sprite_code(machine(), 0, m_spriteram[0x0c] >> 4,   &car2_code, &car2_flipy);
	564	remap_sprite_code(0, m_spriteram[0x0c] >> 4,   &car2_code, &car2_flipy);
570	565
571	566	car3_x = m_spriteram[0x04];
572	567	car3_y = m_spriteram[0x05];
573		remap_sprite_code(machine(), 0, m_spriteram[0x0d] & 0x0f, &car3_code, &car3_flipy);
	568	remap_sprite_code(0, m_spriteram[0x0d] & 0x0f, &car3_code, &car3_flipy);
574	569
575	570	car4_x = m_spriteram[0x06];
576	571	car4_y = m_spriteram[0x07];
577		remap_sprite_code(machine(), 0, m_spriteram[0x0d] >> 4,   &car4_code, &car4_flipy);
	572	remap_sprite_code(0, m_spriteram[0x0d] >> 4,   &car4_code, &car4_flipy);
578	573
579	574	ball_x = m_spriteram[0x08];
580	575	ball_y = m_spriteram[0x09];
581		remap_sprite_code(machine(), 1, m_spriteram[0x0e] & 0x0f, &ball_code, &ball_flipy);
	576	remap_sprite_code(1, m_spriteram[0x0e] & 0x0f, &ball_code, &ball_flipy);
582	577
583	578
584	579	/* cars 1 and 2 */
585		if (check_sprite_sprite_collision(machine(),
586		car1_x, car1_y, car1_code, car1_flipy,
	580	if (check_sprite_sprite_collision(car1_x, car1_y, car1_code, car1_flipy,
587	581	car2_x, car2_y, car2_code, car2_flipy,
588	582	&col_x, &col_y))
589		carpolo_generate_car_car_interrupt(machine(), 0, 1);
	583	carpolo_generate_car_car_interrupt(0, 1);
590	584
591	585	/* cars 1 and 3 */
592		else if (check_sprite_sprite_collision(machine(),
593		car1_x, car1_y, car1_code, car1_flipy,
	586	else if (check_sprite_sprite_collision(car1_x, car1_y, car1_code, car1_flipy,
594	587	car3_x, car3_y, car3_code, car3_flipy,
595	588	&col_x, &col_y))
596		carpolo_generate_car_car_interrupt(machine(), 0, 2);
	589	carpolo_generate_car_car_interrupt(0, 2);
597	590
598	591	/* cars 1 and 4 */
599		else if (check_sprite_sprite_collision(machine(),
600		car1_x, car1_y, car1_code, car1_flipy,
	592	else if (check_sprite_sprite_collision(car1_x, car1_y, car1_code, car1_flipy,
601	593	car4_x, car4_y, car4_code, car4_flipy,
602	594	&col_x, &col_y))
603		carpolo_generate_car_car_interrupt(machine(), 0, 3);
	595	carpolo_generate_car_car_interrupt(0, 3);
604	596
605	597	/* cars 2 and 3 */
606		else if (check_sprite_sprite_collision(machine(),
607		car2_x, car2_y, car2_code, car2_flipy,
	598	else if (check_sprite_sprite_collision(car2_x, car2_y, car2_code, car2_flipy,
608	599	car3_x, car3_y, car3_code, car3_flipy,
609	600	&col_x, &col_y))
610		carpolo_generate_car_car_interrupt(machine(), 1, 2);
	601	carpolo_generate_car_car_interrupt(1, 2);
611	602
612	603	/* cars 2 and 4 */
613		else if (check_sprite_sprite_collision(machine(),
614		car2_x, car2_y, car2_code, car2_flipy,
	604	else if (check_sprite_sprite_collision(car2_x, car2_y, car2_code, car2_flipy,
615	605	car4_x, car4_y, car4_code, car4_flipy,
616	606	&col_x, &col_y))
617		carpolo_generate_car_car_interrupt(machine(), 1, 3);
	607	carpolo_generate_car_car_interrupt(1, 3);
618	608
619	609	/* cars 3 and 4 */
620		else if (check_sprite_sprite_collision(machine(),
621		car3_x, car3_y, car3_code, car3_flipy,
	610	else if (check_sprite_sprite_collision(car3_x, car3_y, car3_code, car3_flipy,
622	611	car4_x, car4_y, car4_code, car4_flipy,
623	612	&col_x, &col_y))
624		carpolo_generate_car_car_interrupt(machine(), 2, 3);
	613	carpolo_generate_car_car_interrupt(2, 3);
625	614
626	615
627	616
628	617	/* check car-ball collision */
629		if (check_sprite_sprite_collision(machine(),
630		car1_x, car1_y, car1_code, car1_flipy,
	618	if (check_sprite_sprite_collision(car1_x, car1_y, car1_code, car1_flipy,
631	619	ball_x, ball_y, ball_code, ball_flipy,
632	620	&col_x, &col_y))
633		carpolo_generate_car_ball_interrupt(machine(), 0, col_x, col_y);
	621	carpolo_generate_car_ball_interrupt(0, col_x, col_y);
634	622
635		else if (check_sprite_sprite_collision(machine(),
636		car2_x, car2_y, car2_code, car2_flipy,
	623	else if (check_sprite_sprite_collision(car2_x, car2_y, car2_code, car2_flipy,
637	624	ball_x, ball_y, ball_code, ball_flipy,
638	625	&col_x, &col_y))
639		carpolo_generate_car_ball_interrupt(machine(), 1, col_x, col_y);
	626	carpolo_generate_car_ball_interrupt(1, col_x, col_y);
640	627
641		else if (check_sprite_sprite_collision(machine(),
642		car3_x, car3_y, car3_code, car3_flipy,
	628	else if (check_sprite_sprite_collision(car3_x, car3_y, car3_code, car3_flipy,
643	629	ball_x, ball_y, ball_code, ball_flipy,
644	630	&col_x, &col_y))
645		carpolo_generate_car_ball_interrupt(machine(), 2, col_x, col_y);
	631	carpolo_generate_car_ball_interrupt(2, col_x, col_y);
646	632
647		else if (check_sprite_sprite_collision(machine(),
648		car4_x, car4_y, car4_code, car4_flipy,
	633	else if (check_sprite_sprite_collision(car4_x, car4_y, car4_code, car4_flipy,
649	634	ball_x, ball_y, ball_code, ball_flipy,
650	635	&col_x, &col_y))
651		carpolo_generate_car_ball_interrupt(machine(), 3, col_x, col_y);
	636	carpolo_generate_car_ball_interrupt(3, col_x, col_y);
652	637
653	638
654	639	/* check car-goal collision */
655		if (check_sprite_left_goal_collision(machine(), car1_x, car1_y, car1_code, car1_flipy, 1))
656		carpolo_generate_car_goal_interrupt(machine(), 0, 0);
	640	if (check_sprite_left_goal_collision(car1_x, car1_y, car1_code, car1_flipy, 1))
	641	carpolo_generate_car_goal_interrupt(0, 0);
657	642
658		else if (check_sprite_right_goal_collision(machine(), car1_x, car1_y, car1_code, car1_flipy, 1))
659		carpolo_generate_car_goal_interrupt(machine(), 0, 1);
	643	else if (check_sprite_right_goal_collision(car1_x, car1_y, car1_code, car1_flipy, 1))
	644	carpolo_generate_car_goal_interrupt(0, 1);
660	645
661		else if (check_sprite_left_goal_collision(machine(), car2_x, car2_y, car2_code, car2_flipy, 1))
662		carpolo_generate_car_goal_interrupt(machine(), 1, 0);
	646	else if (check_sprite_left_goal_collision(car2_x, car2_y, car2_code, car2_flipy, 1))
	647	carpolo_generate_car_goal_interrupt(1, 0);
663	648
664		else if (check_sprite_right_goal_collision(machine(), car2_x, car2_y, car2_code, car2_flipy, 1))
665		carpolo_generate_car_goal_interrupt(machine(), 1, 1);
	649	else if (check_sprite_right_goal_collision(car2_x, car2_y, car2_code, car2_flipy, 1))
	650	carpolo_generate_car_goal_interrupt(1, 1);
666	651
667		else if (check_sprite_left_goal_collision(machine(), car3_x, car3_y, car3_code, car3_flipy, 1))
668		carpolo_generate_car_goal_interrupt(machine(), 2, 0);
	652	else if (check_sprite_left_goal_collision(car3_x, car3_y, car3_code, car3_flipy, 1))
	653	carpolo_generate_car_goal_interrupt(2, 0);
669	654
670		else if (check_sprite_right_goal_collision(machine(), car3_x, car3_y, car3_code, car3_flipy, 1))
671		carpolo_generate_car_goal_interrupt(machine(), 2, 1);
	655	else if (check_sprite_right_goal_collision(car3_x, car3_y, car3_code, car3_flipy, 1))
	656	carpolo_generate_car_goal_interrupt(2, 1);
672	657
673		else if (check_sprite_left_goal_collision(machine(), car4_x, car4_y, car4_code, car4_flipy, 1))
674		carpolo_generate_car_goal_interrupt(machine(), 3, 0);
	658	else if (check_sprite_left_goal_collision(car4_x, car4_y, car4_code, car4_flipy, 1))
	659	carpolo_generate_car_goal_interrupt(3, 0);
675	660
676		else if (check_sprite_right_goal_collision(machine(), car4_x, car4_y, car4_code, car4_flipy, 1))
677		carpolo_generate_car_goal_interrupt(machine(), 3, 1);
	661	else if (check_sprite_right_goal_collision(car4_x, car4_y, car4_code, car4_flipy, 1))
	662	carpolo_generate_car_goal_interrupt(3, 1);
678	663
679	664
680	665	/* check ball collision with static screen elements */
681	666	{
682	667	int col;
683	668
684		col = check_sprite_left_goal_collision(machine(), ball_x, ball_y, ball_code, ball_flipy, 0);
	669	col = check_sprite_left_goal_collision(ball_x, ball_y, ball_code, ball_flipy, 0);
685	670
686		if (col == 1)  carpolo_generate_ball_screen_interrupt(machine(), 0x05);
687		if (col == 2)  carpolo_generate_ball_screen_interrupt(machine(), 0x03);
	671	if (col == 1)  carpolo_generate_ball_screen_interrupt(0x05);
	672	if (col == 2)  carpolo_generate_ball_screen_interrupt(0x03);
688	673
689	674
690		col = check_sprite_right_goal_collision(machine(), ball_x, ball_y, ball_code, ball_flipy, 0);
	675	col = check_sprite_right_goal_collision(ball_x, ball_y, ball_code, ball_flipy, 0);
691	676
692		if (col == 1)  carpolo_generate_ball_screen_interrupt(machine(), 0x05 | 0x08);
693		if (col == 2)  carpolo_generate_ball_screen_interrupt(machine(), 0x03 | 0x08);
	677	if (col == 1)  carpolo_generate_ball_screen_interrupt(0x05 | 0x08);
	678	if (col == 2)  carpolo_generate_ball_screen_interrupt(0x03 | 0x08);
694	679
695	680
696		if (check_sprite_border_collision(machine(), ball_x, ball_y, ball_code, ball_flipy))
697		carpolo_generate_ball_screen_interrupt(machine(), 0x06);
	681	if (check_sprite_border_collision(ball_x, ball_y, ball_code, ball_flipy))
	682	carpolo_generate_ball_screen_interrupt(0x06);
698	683	}
699	684
700	685
r20746	r20747
702	687	{
703	688	int col;
704	689
705		col = check_sprite_border_collision(machine(), car1_x, car1_y, car1_code, car1_flipy);
	690	col = check_sprite_border_collision(car1_x, car1_y, car1_code, car1_flipy);
706	691
707	692	if (col)
708		carpolo_generate_car_border_interrupt(machine(), 0, (col == 2));
	693	carpolo_generate_car_border_interrupt(0, (col == 2));
709	694	else
710	695	{
711		col = check_sprite_border_collision(machine(), car2_x, car2_y, car2_code, car2_flipy);
	696	col = check_sprite_border_collision(car2_x, car2_y, car2_code, car2_flipy);
712	697
713	698	if (col)
714		carpolo_generate_car_border_interrupt(machine(), 1, (col == 2));
	699	carpolo_generate_car_border_interrupt(1, (col == 2));
715	700	else
716	701	{
717		col = check_sprite_border_collision(machine(), car3_x, car3_y, car3_code, car3_flipy);
	702	col = check_sprite_border_collision(car3_x, car3_y, car3_code, car3_flipy);
718	703
719	704	if (col)
720		carpolo_generate_car_border_interrupt(machine(), 2, (col == 2));
	705	carpolo_generate_car_border_interrupt(2, (col == 2));
721	706	else
722	707	{
723		col = check_sprite_border_collision(machine(), car4_x, car4_y, car4_code, car4_flipy);
	708	col = check_sprite_border_collision(car4_x, car4_y, car4_code, car4_flipy);
724	709
725	710	if (col)
726		carpolo_generate_car_border_interrupt(machine(), 3, (col == 2));
	711	carpolo_generate_car_border_interrupt(3, (col == 2));
727	712	}
728	713	}
729	714	}

trunk/src/mame/video/champbas.c

r20746	r20747
188	188
189	189
190	190
191		static void champbas_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	191	void champbas_state::champbas_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
192	192	{
193		champbas_state *state = machine.driver_data<champbas_state>();
194	193	int offs;
195		gfx_element* const gfx = machine.gfx[1];
	194	gfx_element* const gfx = machine().gfx[1];
196	195
197		for (offs = state->m_spriteram.bytes() - 2; offs >= 0; offs -= 2)
	196	for (offs = m_spriteram.bytes() - 2; offs >= 0; offs -= 2)
198	197	{
199		int code = (state->m_spriteram[offs] >> 2) | (state->m_gfx_bank << 6);
200		int color = (state->m_spriteram[offs + 1] & 0x1f) | (state->m_palette_bank << 6);
201		int flipx = ~state->m_spriteram[offs] & 0x01;
202		int flipy = ~state->m_spriteram[offs] & 0x02;
203		int sx = state->m_spriteram_2[offs + 1] - 16;
204		int sy = 255 - state->m_spriteram_2[offs];
	198	int code = (m_spriteram[offs] >> 2) | (m_gfx_bank << 6);
	199	int color = (m_spriteram[offs + 1] & 0x1f) | (m_palette_bank << 6);
	200	int flipx = ~m_spriteram[offs] & 0x01;
	201	int flipy = ~m_spriteram[offs] & 0x02;
	202	int sx = m_spriteram_2[offs + 1] - 16;
	203	int sy = 255 - m_spriteram_2[offs];
205	204
206	205	drawgfx_transmask(bitmap, cliprect,
207	206	gfx,
208	207	code, color,
209	208	flipx, flipy,
210	209	sx, sy,
211		colortable_get_transpen_mask(machine.colortable, gfx, color, 0));
	210	colortable_get_transpen_mask(machine().colortable, gfx, color, 0));
212	211
213	212	// wraparound
214	213	drawgfx_transmask(bitmap, cliprect,
r20746	r20747
216	215	code, color,
217	216	flipx, flipy,
218	217	sx + 256, sy,
219		colortable_get_transpen_mask(machine.colortable, gfx, color, 0));
	218	colortable_get_transpen_mask(machine().colortable, gfx, color, 0));
220	219	}
221	220	}
222	221
223		static void exctsccr_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	222	void champbas_state::exctsccr_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
224	223	{
225		champbas_state *state = machine.driver_data<champbas_state>();
226	224	int offs;
227	225	UINT8 *obj1, *obj2;
228	226
229		obj1 = state->m_bg_videoram;
230		obj2 = &(state->m_spriteram[0x20]);
	227	obj1 = m_bg_videoram;
	228	obj2 = &(m_spriteram[0x20]);
231	229
232	230	for (offs = 0x0e; offs >= 0; offs -= 2)
233	231	{
r20746	r20747
243	241	bank = ((obj1[offs + 1] >> 4) & 1);
244	242
245	243	drawgfx_transpen(bitmap,cliprect,
246		machine.gfx[1],
	244	machine().gfx[1],
247	245	code + (bank << 6),
248	246	color,
249	247	flipx, flipy,
250	248	sx,sy,0);
251	249	}
252	250
253		obj1 = state->m_spriteram_2;
254		obj2 = state->m_spriteram;
	251	obj1 = m_spriteram_2;
	252	obj2 = m_spriteram;
255	253
256	254	for (offs = 0x0e; offs >= 0; offs -= 2)
257	255	{
r20746	r20747
266	264	color = (obj1[offs + 1]) & 0x0f;
267	265
268	266	drawgfx_transmask(bitmap,cliprect,
269		machine.gfx[2],
	267	machine().gfx[2],
270	268	code,
271	269	color,
272	270	flipx, flipy,
273	271	sx,sy,
274		colortable_get_transpen_mask(machine.colortable, machine.gfx[2], color, 0x10));
	272	colortable_get_transpen_mask(machine().colortable, machine().gfx[2], color, 0x10));
275	273	}
276	274	}
277	275
r20746	r20747
280	278	UINT32 champbas_state::screen_update_champbas(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
281	279	{
282	280	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
283		champbas_draw_sprites(machine(), bitmap, cliprect);
	281	champbas_draw_sprites(bitmap, cliprect);
284	282	return 0;
285	283	}
286	284
287	285	UINT32 champbas_state::screen_update_exctsccr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
288	286	{
289	287	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
290		exctsccr_draw_sprites(machine(), bitmap, cliprect);
	288	exctsccr_draw_sprites(bitmap, cliprect);
291	289	return 0;
292	290	}

trunk/src/mame/video/crshrace.c

r20746	r20747
95	95
96	96	***************************************************************************/
97	97
98		static void draw_bg( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	98	void crshrace_state::draw_bg( bitmap_ind16 &bitmap, const rectangle &cliprect )
99	99	{
100		crshrace_state *state = machine.driver_data<crshrace_state>();
101		state->m_tilemap2->draw(bitmap, cliprect, 0, 0);
	100	m_tilemap2->draw(bitmap, cliprect, 0, 0);
102	101	}
103	102
104	103
105		static void draw_fg(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	104	void crshrace_state::draw_fg(bitmap_ind16 &bitmap, const rectangle &cliprect)
106	105	{
107		crshrace_state *state = machine.driver_data<crshrace_state>();
108		k053936_zoom_draw(state->m_k053936, bitmap, cliprect, state->m_tilemap1, 0, 0, 1);
	106	k053936_zoom_draw(m_k053936, bitmap, cliprect, m_tilemap1, 0, 0, 1);
109	107	}
110	108
111	109
r20746	r20747
125	123	{
126	124	case 0x00:  /* high score screen */
127	125	m_spr->draw_sprites(m_spriteram->buffer(), 0x2000,  machine(), bitmap, cliprect);
128		draw_bg(machine(), bitmap, cliprect);
129		draw_fg(machine(), bitmap, cliprect);
	126	draw_bg(bitmap, cliprect);
	127	draw_fg(bitmap, cliprect);
130	128	break;
131	129	case 0x01:
132	130	case 0x02:
133		draw_bg(machine(), bitmap, cliprect);
134		draw_fg(machine(), bitmap, cliprect);
	131	draw_bg(bitmap, cliprect);
	132	draw_fg(bitmap, cliprect);
135	133	m_spr->draw_sprites(m_spriteram->buffer(), 0x2000,  machine(), bitmap, cliprect);
136	134	break;
137	135	default:

trunk/src/mame/video/cchasm.c

r20746	r20747
24	24	machine().device("maincpu")->execute().set_input_line(2, ASSERT_LINE);
25	25	}
26	26
27		static void cchasm_refresh (running_machine &machine)
	27	void cchasm_state::cchasm_refresh ()
28	28	{
29		cchasm_state *state = machine.driver_data<cchasm_state>();
30	29
31	30	int pc = 0;
32	31	int done = 0;
r20746	r20747
41	40
42	41	while (!done)
43	42	{
44		data = state->m_ram[pc];
	43	data = m_ram[pc];
45	44	opcode = data >> 12;
46	45	data &= 0xfff;
47	46	if ((opcode > COLOR) && (data & 0x800))
r20746	r20747
66	65	break;
67	66	case POSY:
68	67	move = 1;
69		currenty = state->m_ycenter + (data << 16);
	68	currenty = m_ycenter + (data << 16);
70	69	break;
71	70	case SCALEX:
72	71	scalex = data << 5;
73	72	break;
74	73	case POSX:
75	74	move = 1;
76		currentx = state->m_xcenter - (data << 16);
	75	currentx = m_xcenter - (data << 16);
77	76	break;
78	77	case LENGTH:
79	78	if (move)
80	79	{
81		vector_add_point (machine, currentx, currenty, 0, 0);
	80	vector_add_point (machine(), currentx, currenty, 0, 0);
82	81	move = 0;
83	82	}
84	83
r20746	r20747
88	87	total_length += abs(data);
89	88
90	89	if (color)
91		vector_add_point (machine, currentx, currenty, color, 0xff);
	90	vector_add_point (machine(), currentx, currenty, color, 0xff);
92	91	else
93	92	move = 1;
94	93	break;
r20746	r20747
99	98	}
100	99	}
101	100	/* Refresh processor runs with 6 MHz */
102		machine.scheduler().timer_set (attotime::from_hz(6000000) * total_length, timer_expired_delegate(FUNC(cchasm_state::cchasm_refresh_end),state));
	101	machine().scheduler().timer_set (attotime::from_hz(6000000) * total_length, timer_expired_delegate(FUNC(cchasm_state::cchasm_refresh_end),this));
103	102	}
104	103
105	104
r20746	r20747
110	109	switch (data >> 8)
111	110	{
112	111	case 0x37:
113		cchasm_refresh(machine());
	112	cchasm_refresh();
114	113	break;
115	114	case 0xf7:
116	115	machine().device("maincpu")->execute().set_input_line(2, CLEAR_LINE);

trunk/src/mame/video/clshroad.c

r20746	r20747
280	280
281	281	***************************************************************************/
282	282
283		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	283	void clshroad_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
284	284	{
285		clshroad_state *state = machine.driver_data<clshroad_state>();
286		UINT8 *spriteram = state->m_spriteram;
	285	UINT8 *spriteram = m_spriteram;
287	286	int i;
288	287
289		for (i = 0; i < state->m_spriteram.bytes() ; i += 8)
	288	for (i = 0; i < m_spriteram.bytes() ; i += 8)
290	289	{
291	290	int y       =    240 - spriteram[i+1];
292	291	int code    =   (spriteram[i+3] & 0x3f) + (spriteram[i+2] << 6);
r20746	r20747
297	296	int flipy   =   0;
298	297
299	298	x -= 0x4a/2;
300		if (state->flip_screen())
	299	if (flip_screen())
301	300	{
302	301	y = 240 - y;
303	302	flipx = !flipx;
304	303	flipy = !flipy;
305	304	}
306	305
307		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	306	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
308	307	code,
309	308	attr & 0x0f,
310	309	flipx,flipy,
r20746	r20747
332	331
333	332	m_tilemap_0a->draw(bitmap, cliprect, 0,0);  // Opaque
334	333	m_tilemap_0b->draw(bitmap, cliprect, 0,0);
335		draw_sprites(machine(),bitmap,cliprect);
	334	draw_sprites(bitmap,cliprect);
336	335	m_tilemap_1->draw(bitmap, cliprect, 0,0);
337	336	return 0;
338	337	}

trunk/src/mame/video/changela.c

r20746	r20747
40	40
41	41	***************************************************************************/
42	42
43		static void draw_obj0( running_machine &machine, bitmap_ind16 &bitmap, int sy )
	43	void changela_state::draw_obj0( bitmap_ind16 &bitmap, int sy )
44	44	{
45		changela_state *state = machine.driver_data<changela_state>();
46	45	int sx, i;
47	46
48		UINT8* ROM = state->memregion("user1")->base();
49		UINT8* RAM = state->m_spriteram;
	47	UINT8* ROM = memregion("user1")->base();
	48	UINT8* RAM = m_spriteram;
50	49
51	50	for (sx = 0; sx < 256; sx++)
52	51	{
r20746	r20747
103	102
104	103	***************************************************************************/
105	104
106		static void draw_obj1( running_machine &machine, bitmap_ind16 &bitmap )
	105	void changela_state::draw_obj1( bitmap_ind16 &bitmap )
107	106	{
108		changela_state *state = machine.driver_data<changela_state>();
109	107	int sx, sy;
110	108
111		UINT8* ROM = state->memregion("gfx2")->base();
112		UINT8* RAM = state->m_videoram;
	109	UINT8* ROM = memregion("gfx2")->base();
	110	UINT8* RAM = m_videoram;
113	111
114	112	UINT8 reg[4] = { 0 }; /* 4x4-bit registers (U58, U59) */
115	113
r20746	r20747
168	166
169	167	***************************************************************************/
170	168
171		static void draw_river( running_machine &machine, bitmap_ind16 &bitmap, int sy )
	169	void changela_state::draw_river( bitmap_ind16 &bitmap, int sy )
172	170	{
173		changela_state *state = machine.driver_data<changela_state>();
174	171	int sx, i, j;
175	172
176		UINT8* ROM = state->memregion("user2")->base();
177		UINT8* RAM = state->m_memory_devices + 0x800;
178		UINT8* TILE_ROM = state->memregion("gfx1")->base();
179		UINT8* TILE_RAM = state->m_memory_devices + 0x1000;
180		UINT8* PROM = state->memregion("proms")->base();
	173	UINT8* ROM = memregion("user2")->base();
	174	UINT8* RAM = m_memory_devices + 0x800;
	175	UINT8* TILE_ROM = memregion("gfx1")->base();
	176	UINT8* TILE_RAM = m_memory_devices + 0x1000;
	177	UINT8* PROM = memregion("proms")->base();
181	178
182	179	int preload = ((sy < 32) ? 1 : 0);
183	180
r20746	r20747
194	191	int carry = 0;
195	192
196	193	/* Update Counters */
197		if (sy == 30) state->m_v_count_river = state->m_horizon;
198		state->m_v_count_river = (state->m_v_count_river + 1) & 0xff;
	194	if (sy == 30) m_v_count_river = m_horizon;
	195	m_v_count_river = (m_v_count_river + 1) & 0xff;
199	196
200	197	/* ----- STATE MACHINE ----- */
201	198	for (i = 0; i < 0x20; i++)
r20746	r20747
219	216	if (prev_state & 0x10)
220	217	hosc = (math_train[8] << 4) | math_train[9];
221	218
222		rom_addr = state->m_slopeROM_bank | ((state->m_v_count_river & 0x7e) << 2) | ((rom_count & 0x0e) >> 1);
	219	rom_addr = m_slopeROM_bank | ((m_v_count_river & 0x7e) << 2) | ((rom_count & 0x0e) >> 1);
223	220	ram_a5 = ((curr_state & 0x01) & ((curr_state & 0x40) >> 6) & preload) ^ 0x01;
224	221	ram_addr =  (ram_a5 << 5) | (ram_count << 1) | ((curr_state & 0x20) >> 5);
225	222	mux45 = rom_count & 0x01;
226		mux61 = state->m_v_count_river & 0x01;
	223	mux61 = m_v_count_river & 0x01;
227	224
228	225	switch (curr_state)
229	226	{
r20746	r20747
270	267	prev_state = curr_state;
271	268	}
272	269
273		if (!(state->m_v_count_river & 0x80))
	270	if (!(m_v_count_river & 0x80))
274	271	{
275	272	int h_count = 0x80 | (hosc >> 1);
276	273	int tile_v = ((math_train[3] & 0x0c) >> 2) | ((math_train[2] & 0x0f) << 2) | ((math_train[1] & 0x07) << 6);
r20746	r20747
347	344
348	345	***************************************************************************/
349	346
350		static void draw_tree( running_machine &machine, bitmap_ind16 &bitmap, int sy, int tree_num )
	347	void changela_state::draw_tree( bitmap_ind16 &bitmap, int sy, int tree_num )
351	348	{
352		changela_state *state = machine.driver_data<changela_state>();
353	349	int sx, i, j;
354	350
355	351	/* State machine */
356		UINT8* ROM = state->memregion("user2")->base();
357		UINT8* RAM = state->m_memory_devices + 0x840 + 0x40 * tree_num;
358		UINT8* PROM = state->memregion("proms")->base();
	352	UINT8* ROM = memregion("user2")->base();
	353	UINT8* RAM = m_memory_devices + 0x840 + 0x40 * tree_num;
	354	UINT8* PROM = memregion("proms")->base();
359	355
360	356	/* Tree Data */
361		UINT8* RAM2 = state->m_tree_ram + 0x20 * tree_num;
362		UINT8* TILE_ROM = (tree_num ? (state->memregion("user3")->base() + 0x1000) : (state->memregion("gfx1")->base() + 0x2000));
363		UINT8* TILE_RAM = (tree_num ? (state->memregion("user3")->base()) : (state->m_memory_devices + 0x1800));
	357	UINT8* RAM2 = m_tree_ram + 0x20 * tree_num;
	358	UINT8* TILE_ROM = (tree_num ? (memregion("user3")->base() + 0x1000) : (memregion("gfx1")->base() + 0x2000));
	359	UINT8* TILE_RAM = (tree_num ? (memregion("user3")->base()) : (m_memory_devices + 0x1800));
364	360
365	361	int preload = ((sy < 32) ? 1 : 0);
366	362
r20746	r20747
384	380	/* Update Counters */
385	381	if (sy == 30)
386	382	{
387		state->m_tree_on[tree_num] = 0;
	383	m_tree_on[tree_num] = 0;
388	384	if (tree_num == 0)
389		state->m_v_count_tree = state->m_horizon;
	385	m_v_count_tree = m_horizon;
390	386	}
391	387	if (tree_num == 0)
392		state->m_v_count_tree = (state->m_v_count_tree + 1) & 0xff;
	388	m_v_count_tree = (m_v_count_tree + 1) & 0xff;
393	389
394	390	/* ----- STATE MACHINE ----- */
395	391	for (i = 0; i < 0x20; i++)
r20746	r20747
416	412	if (prev_state & 0x10)
417	413	hosc = (math_train[8] << 4) | math_train[9];
418	414
419		rom_addr = state->m_slopeROM_bank | ((state->m_v_count_tree & 0x7e) << 2) | ((rom_count & 0x0e) >> 1);
	415	rom_addr = m_slopeROM_bank | ((m_v_count_tree & 0x7e) << 2) | ((rom_count & 0x0e) >> 1);
420	416	ram_a5 = ((curr_state & 0x01) & ((curr_state & 0x40) >> 6) & preload) ^ 0x01;
421	417	ram_addr = (ram_a5 << 5) | (ram_count << 1) | ((curr_state & 0x20) >> 5);
422	418	ram2_addr = (ram_count << 1) | ((curr_state & 0x20) >> 5);
423	419	mux45 = rom_count & 0x01;
424		mux61 = state->m_v_count_tree & 0x01;
	420	mux61 = m_v_count_tree & 0x01;
425	421
426	422	switch(curr_state)
427	423	{
r20746	r20747
441	437	break;
442	438	}
443	439
444		if (!state->m_tree_on[tree_num])
	440	if (!m_tree_on[tree_num])
445	441	{
446		int mux82 = (state->m_v_count_tree & 0x01) ^ 0x01;
	442	int mux82 = (m_v_count_tree & 0x01) ^ 0x01;
447	443
448	444	switch(curr_state)
449	445	{
r20746	r20747
531	527	ram_addr = ((tile_h & 0x1f8) >> 3) | ((tile_v & 0x1f0) << 2);
532	528	rom_addr = ((tile_h & 0x06) >> 1) | ((tile_v & 0x0f) << 2) | ((TILE_RAM[ram_addr] & 0x7f) << 6);
533	529
534		if (!(state->m_v_count_tree & 0x80) && (state->m_tree_en & (0x01 << tree_num)) && ((TILE_ROM[rom_addr] & 0xf0) == 0))
535		state->m_tree_on[tree_num] = 1;
	530	if (!(m_v_count_tree & 0x80) && (m_tree_en & (0x01 << tree_num)) && ((TILE_ROM[rom_addr] & 0xf0) == 0))
	531	m_tree_on[tree_num] = 1;
536	532
537		if (state->m_tree_on[tree_num])
	533	if (m_tree_on[tree_num])
538	534	{
539	535	if (tile_h & 0x01)
540	536	col = TILE_ROM[rom_addr] & 0x0f;
r20746	r20747
571	567	ram_addr = ((tile_h & 0x1f8) >> 3) | ((tile_v & 0x1f0) << 2);
572	568	rom_addr = ((tile_h & 0x06) >> 1) | ((tile_v & 0x0f) << 2) | ((TILE_RAM[ram_addr] & 0x7f) << 6);
573	569
574		if (!(state->m_v_count_tree & 0x80) && (state->m_tree_en & (0x01 << tree_num)) && ((TILE_ROM[rom_addr] & 0xf0) == 0))
575		state->m_tree_on[tree_num] = 1;
	570	if (!(m_v_count_tree & 0x80) && (m_tree_en & (0x01 << tree_num)) && ((TILE_ROM[rom_addr] & 0xf0) == 0))
	571	m_tree_on[tree_num] = 1;
576	572
577		if (state->m_tree_on[tree_num])
	573	if (m_tree_on[tree_num])
578	574	{
579	575	if (tile_h & 0x01)
580	576	col = TILE_ROM[rom_addr] & 0x0f;
r20746	r20747
591	587
592	588	/* Tree on only stays high if a pixel that is not 0xf is encountered,
593	589	because any non 0xf pixel sets U56 high */
594		if (all_ff) state->m_tree_on[tree_num] = 0;
	590	if (all_ff) m_tree_on[tree_num] = 0;
595	591	}
596	592
597	593	/*
r20746	r20747
655	651	m_tree0_bitmap.fill(0x00, rect);
656	652	m_tree1_bitmap.fill(0x00, rect);
657	653
658		draw_river(machine(), m_river_bitmap, sy);
659		draw_obj0(machine(), m_obj0_bitmap, sy);
660		draw_tree(machine(), m_tree0_bitmap, sy, 0);
661		draw_tree(machine(), m_tree1_bitmap, sy, 1);
	654	draw_river(m_river_bitmap, sy);
	655	draw_obj0(m_obj0_bitmap, sy);
	656	draw_tree(m_tree0_bitmap, sy, 0);
	657	draw_tree(m_tree1_bitmap, sy, 1);
662	658
663	659	/* Collision Detection */
664	660	for (sx = 1; sx < 256; sx++)
r20746	r20747
725	721	copybitmap_trans(bitmap, m_obj0_bitmap,  0, 0, 0, 0, cliprect, 0);
726	722	copybitmap_trans(bitmap, m_tree0_bitmap, 0, 0, 0, 0, cliprect, 0);
727	723	copybitmap_trans(bitmap, m_tree1_bitmap, 0, 0, 0, 0, cliprect, 0);
728		draw_obj1(machine(), bitmap);
	724	draw_obj1(bitmap);
729	725
730	726	return 0;
731	727	}

trunk/src/mame/video/ccastles.c

r20746	r20747
115	115	*
116	116	*************************************/
117	117
118		INLINE void ccastles_write_vram( running_machine &machine, UINT16 addr, UINT8 data, UINT8 bitmd, UINT8 pixba )
	118	inline void ccastles_state::ccastles_write_vram( UINT16 addr, UINT8 data, UINT8 bitmd, UINT8 pixba )
119	119	{
120		ccastles_state *state = machine.driver_data<ccastles_state>();
121		UINT8 *dest = &state->m_videoram[addr & 0x7ffe];
	120	UINT8 *dest = &m_videoram[addr & 0x7ffe];
122	121	UINT8 promaddr = 0;
123	122	UINT8 wpbits;
124	123
r20746	r20747
141	140	promaddr |= (pixba << 0);
142	141
143	142	/* look up the PROM result */
144		wpbits = state->m_wpprom[promaddr];
	143	wpbits = m_wpprom[promaddr];
145	144
146	145	/* write to the appropriate parts of VRAM depending on the result */
147	146	if (!(wpbits & 1))
r20746	r20747
162	161	*
163	162	*************************************/
164	163
165		INLINE void bitmode_autoinc( running_machine &machine )
	164	inline void ccastles_state::bitmode_autoinc(  )
166	165	{
167		ccastles_state *state = machine.driver_data<ccastles_state>();
168	166
169	167	/* auto increment in the x-direction if it's enabled */
170		if (!state->m_video_control[0]) /* /AX */
	168	if (!m_video_control[0]) /* /AX */
171	169	{
172		if (!state->m_video_control[2]) /* /XINC */
173		state->m_bitmode_addr[0]++;
	170	if (!m_video_control[2]) /* /XINC */
	171	m_bitmode_addr[0]++;
174	172	else
175		state->m_bitmode_addr[0]--;
	173	m_bitmode_addr[0]--;
176	174	}
177	175
178	176	/* auto increment in the y-direction if it's enabled */
179		if (!state->m_video_control[1]) /* /AY */
	177	if (!m_video_control[1]) /* /AY */
180	178	{
181		if (!state->m_video_control[3]) /* /YINC */
182		state->m_bitmode_addr[1]++;
	179	if (!m_video_control[3]) /* /YINC */
	180	m_bitmode_addr[1]++;
183	181	else
184		state->m_bitmode_addr[1]--;
	182	m_bitmode_addr[1]--;
185	183	}
186	184	}
187	185
r20746	r20747
196	194	WRITE8_MEMBER(ccastles_state::ccastles_videoram_w)
197	195	{
198	196	/* direct writes to VRAM go through the write protect PROM as well */
199		ccastles_write_vram(machine(), offset, data, 0, 0);
	197	ccastles_write_vram(offset, data, 0, 0);
200	198	}
201	199
202	200
r20746	r20747
216	214	UINT8 result = m_videoram[addr] << ((~m_bitmode_addr[0] & 1) * 4);
217	215
218	216	/* autoincrement because /BITMD was selected */
219		bitmode_autoinc(machine());
	217	bitmode_autoinc();
220	218
221	219	/* the low 4 bits of the data lines are not driven so make them all 1's */
222	220	return result | 0x0f;
r20746	r20747
232	230	data = (data & 0xf0) | (data >> 4);
233	231
234	232	/* write through the generic VRAM routine, passing the low 2 X bits as PIXB/PIXA */
235		ccastles_write_vram(machine(), addr, data, 1, m_bitmode_addr[0] & 3);
	233	ccastles_write_vram(addr, data, 1, m_bitmode_addr[0] & 3);
236	234
237	235	/* autoincrement because /BITMD was selected */
238		bitmode_autoinc(machine());
	236	bitmode_autoinc();
239	237	}
240	238
241	239
242	240	WRITE8_MEMBER(ccastles_state::ccastles_bitmode_addr_w)
243	241	{
244	242	/* write through to video RAM and also to the addressing latches */
245		ccastles_write_vram(machine(), offset, data, 0, 0);
	243	ccastles_write_vram(offset, data, 0, 0);
246	244	m_bitmode_addr[offset] = data;
247	245	}
248	246

trunk/src/mame/video/chaknpop.c

r20746	r20747
173	173	Screen refresh
174	174	***************************************************************************/
175	175
176		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	176	void chaknpop_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
177	177	{
178		chaknpop_state *state = machine.driver_data<chaknpop_state>();
179	178	int offs;
180	179
181	180	/* Draw the sprites */
182		for (offs = 0; offs < state->m_spr_ram.bytes(); offs += 4)
	181	for (offs = 0; offs < m_spr_ram.bytes(); offs += 4)
183	182	{
184		int sx = state->m_spr_ram[offs + 3];
185		int sy = 256 - 15 - state->m_spr_ram[offs];
186		int flipx = state->m_spr_ram[offs+1] & 0x40;
187		int flipy = state->m_spr_ram[offs+1] & 0x80;
188		int color = (state->m_spr_ram[offs + 2] & 7);
189		int tile = (state->m_spr_ram[offs + 1] & 0x3f) | ((state->m_spr_ram[offs + 2] & 0x38) << 3);
	183	int sx = m_spr_ram[offs + 3];
	184	int sy = 256 - 15 - m_spr_ram[offs];
	185	int flipx = m_spr_ram[offs+1] & 0x40;
	186	int flipy = m_spr_ram[offs+1] & 0x80;
	187	int color = (m_spr_ram[offs + 2] & 7);
	188	int tile = (m_spr_ram[offs + 1] & 0x3f) | ((m_spr_ram[offs + 2] & 0x38) << 3);
190	189
191		if (state->m_flip_x)
	190	if (m_flip_x)
192	191	{
193	192	sx = 240 - sx;
194	193	flipx = !flipx;
195	194	}
196		if (state->m_flip_y)
	195	if (m_flip_y)
197	196	{
198	197	sy = 242 - sy;
199	198	flipy = !flipy;
200	199	}
201	200
202	201	drawgfx_transpen(bitmap,cliprect,
203		machine.gfx[0],
	202	machine().gfx[0],
204	203	tile,
205	204	color,
206	205	flipx, flipy,
r20746	r20747
208	207	}
209	208	}
210	209
211		static void draw_bitmap( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	210	void chaknpop_state::draw_bitmap( bitmap_ind16 &bitmap, const rectangle &cliprect )
212	211	{
213		chaknpop_state *state = machine.driver_data<chaknpop_state>();
214		int dx = state->m_flip_x ? -1 : 1;
	212	int dx = m_flip_x ? -1 : 1;
215	213	int offs, i;
216	214
217	215	for (offs = 0; offs < 0x2000; offs++)
r20746	r20747
219	217	int x = ((offs & 0x1f) << 3) + 7;
220	218	int y = offs >> 5;
221	219
222		if (!state->m_flip_x)
	220	if (!m_flip_x)
223	221	x = 255 - x;
224	222
225		if (!state->m_flip_y)
	223	if (!m_flip_y)
226	224	y = 255 - y;
227	225
228	226	for (i = 0x80; i > 0; i >>= 1, x += dx)
229	227	{
230	228	pen_t color = 0;
231	229
232		if (state->m_vram1[offs] & i)
	230	if (m_vram1[offs] & i)
233	231	color |= 0x200; // green lower cage
234		if (state->m_vram2[offs] & i)
	232	if (m_vram2[offs] & i)
235	233	color |= 0x080;
236		if (state->m_vram3[offs] & i)
	234	if (m_vram3[offs] & i)
237	235	color |= 0x100; // green upper cage
238		if (state->m_vram4[offs] & i)
	236	if (m_vram4[offs] & i)
239	237	color |= 0x040; // tx mask
240	238
241	239	if (color)
r20746	r20747
251	249	UINT32 chaknpop_state::screen_update_chaknpop(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
252	250	{
253	251	m_tx_tilemap->draw(bitmap, cliprect, 0, 0);
254		draw_sprites(machine(), bitmap, cliprect);
255		draw_bitmap(machine(), bitmap, cliprect);
	252	draw_sprites(bitmap, cliprect);
	253	draw_bitmap(bitmap, cliprect);
256	254	return 0;
257	255	}

trunk/src/mame/video/citycon.c

r20746	r20747
99	99
100	100
101	101
102		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	102	void citycon_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
103	103	{
104		citycon_state *state = machine.driver_data<citycon_state>();
105	104	int offs;
106	105
107		for (offs = state->m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
	106	for (offs = m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
108	107	{
109	108	int sx, sy, flipx;
110	109
111		sx = state->m_spriteram[offs + 3];
112		sy = 239 - state->m_spriteram[offs];
113		flipx = ~state->m_spriteram[offs + 2] & 0x10;
114		if (state->flip_screen())
	110	sx = m_spriteram[offs + 3];
	111	sy = 239 - m_spriteram[offs];
	112	flipx = ~m_spriteram[offs + 2] & 0x10;
	113	if (flip_screen())
115	114	{
116	115	sx = 240 - sx;
117	116	sy = 238 - sy;
118	117	flipx = !flipx;
119	118	}
120	119
121		drawgfx_transpen(bitmap, cliprect, machine.gfx[state->m_spriteram[offs + 1] & 0x80 ? 2 : 1],
122		state->m_spriteram[offs + 1] & 0x7f,
123		state->m_spriteram[offs + 2] & 0x0f,
124		flipx,state->flip_screen(),
	120	drawgfx_transpen(bitmap, cliprect, machine().gfx[m_spriteram[offs + 1] & 0x80 ? 2 : 1],
	121	m_spriteram[offs + 1] & 0x7f,
	122	m_spriteram[offs + 2] & 0x0f,
	123	flipx,flip_screen(),
125	124	sx, sy, 0);
126	125	}
127	126	}
128	127
129	128
130		INLINE void changecolor_RRRRGGGGBBBBxxxx( running_machine &machine, int color, int indx )
	129	inline void citycon_state::changecolor_RRRRGGGGBBBBxxxx( int color, int indx )
131	130	{
132		citycon_state *state = machine.driver_data<citycon_state>();
133		int data = state->m_generic_paletteram_8[2 * indx | 1] | (state->m_generic_paletteram_8[2 * indx] << 8);
134		palette_set_color_rgb(machine, color, pal4bit(data >> 12), pal4bit(data >> 8), pal4bit(data >> 4));
	131	int data = m_generic_paletteram_8[2 * indx | 1] | (m_generic_paletteram_8[2 * indx] << 8);
	132	palette_set_color_rgb(machine(), color, pal4bit(data >> 12), pal4bit(data >> 8), pal4bit(data >> 4));
135	133	}
136	134
137	135	UINT32 citycon_state::screen_update_citycon(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
r20746	r20747
145	143	int i;
146	144
147	145	for (i = 0; i < 4; i++)
148		changecolor_RRRRGGGGBBBBxxxx(machine(), 640 + 4 * offs + i, 512 + 4 * indx + i);
	146	changecolor_RRRRGGGGBBBBxxxx(640 + 4 * offs + i, 512 + 4 * indx + i);
149	147	}
150	148
151	149
r20746	r20747
156	154
157	155	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
158	156	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
159		draw_sprites(machine(), bitmap, cliprect);
	157	draw_sprites(bitmap, cliprect);
160	158	return 0;
161	159	}

trunk/src/mame/video/capbowl.c

r20746	r20747
152	152	*
153	153	*************************************/
154	154
155		INLINE rgb_t pen_for_pixel( UINT8 *src, UINT8 pix )
	155	inline rgb_t capbowl_state::pen_for_pixel( UINT8 *src, UINT8 pix )
156	156	{
157	157	return MAKE_RGB(pal4bit(src[(pix << 1) + 0] >> 0),
158	158	pal4bit(src[(pix << 1) + 1] >> 4),

trunk/src/mame/video/cclimber.c

r20746	r20747
11	11	#include "includes/cclimber.h"
12	12
13	13
14		#define CCLIMBER_FLIP_X     (state->m_flip_screen[0] & 0x01)
15		#define CCLIMBER_FLIP_Y     (state->m_flip_screen[1] & 0x01)
	14	#define CCLIMBER_FLIP_X     (m_flip_screen[0] & 0x01)
	15	#define CCLIMBER_FLIP_Y     (m_flip_screen[1] & 0x01)
16	16	#define CCLIMBER_BG_PEN     (0)
17	17	#define SWIMMER_SIDE_BG_PEN (0x120)
18	18	#define SWIMMER_BG_SPLIT    (0x18 * 8)
r20746	r20747
300	300
301	301	***************************************************************************/
302	302
303		static void swimmer_set_background_pen(running_machine &machine)
	303	void cclimber_state::swimmer_set_background_pen()
304	304	{
305		cclimber_state *state = machine.driver_data<cclimber_state>();
306	305	int bit0, bit1, bit2;
307	306	int r, g, b;
308	307
309	308	/* red component */
310	309	bit0 = 0;
311		bit1 = (*state->m_swimmer_background_color >> 6) & 0x01;
312		bit2 = (*state->m_swimmer_background_color >> 7) & 0x01;
	310	bit1 = (*m_swimmer_background_color >> 6) & 0x01;
	311	bit2 = (*m_swimmer_background_color >> 7) & 0x01;
313	312	r = 0x20 * bit0 + 0x40 * bit1 + 0x80 * bit2;
314	313
315	314	/* green component */
316		bit0 = (*state->m_swimmer_background_color >> 3) & 0x01;
317		bit1 = (*state->m_swimmer_background_color >> 4) & 0x01;
318		bit2 = (*state->m_swimmer_background_color >> 5) & 0x01;
	315	bit0 = (*m_swimmer_background_color >> 3) & 0x01;
	316	bit1 = (*m_swimmer_background_color >> 4) & 0x01;
	317	bit2 = (*m_swimmer_background_color >> 5) & 0x01;
319	318	g = 0x20 * bit0 + 0x40 * bit1 + 0x80 * bit2;
320	319
321	320	/* blue component */
322		bit0 = (*state->m_swimmer_background_color >> 0) & 0x01;
323		bit1 = (*state->m_swimmer_background_color >> 1) & 0x01;
324		bit2 = (*state->m_swimmer_background_color >> 2) & 0x01;
	321	bit0 = (*m_swimmer_background_color >> 0) & 0x01;
	322	bit1 = (*m_swimmer_background_color >> 1) & 0x01;
	323	bit2 = (*m_swimmer_background_color >> 2) & 0x01;
325	324	b = 0x20 * bit0 + 0x40 * bit1 + 0x80 * bit2;
326	325
327		palette_set_color(machine, CCLIMBER_BG_PEN, MAKE_RGB(r, g, b));
	326	palette_set_color(machine(), CCLIMBER_BG_PEN, MAKE_RGB(r, g, b));
328	327	}
329	328
330	329
r20746	r20747
480	479	}
481	480
482	481
483		static void draw_playfield(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	482	void cclimber_state::draw_playfield(bitmap_ind16 &bitmap, const rectangle &cliprect)
484	483	{
485		cclimber_state *state = machine.driver_data<cclimber_state>();
486	484	int i;
487	485
488		state->m_pf_tilemap->mark_all_dirty();
489		state->m_pf_tilemap->set_flip((CCLIMBER_FLIP_X ? TILEMAP_FLIPX : 0) |
	486	m_pf_tilemap->mark_all_dirty();
	487	m_pf_tilemap->set_flip((CCLIMBER_FLIP_X ? TILEMAP_FLIPX : 0) |
490	488	(CCLIMBER_FLIP_Y ? TILEMAP_FLIPY : 0));
491	489	for (i = 0; i < 32; i++)
492		state->m_pf_tilemap->set_scrolly(i, state->m_column_scroll[i]);
	490	m_pf_tilemap->set_scrolly(i, m_column_scroll[i]);
493	491
494		state->m_pf_tilemap->draw(bitmap, cliprect, 0, 0);
	492	m_pf_tilemap->draw(bitmap, cliprect, 0, 0);
495	493	}
496	494
497	495
498		static void cclimber_draw_bigsprite(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	496	void cclimber_state::cclimber_draw_bigsprite(bitmap_ind16 &bitmap, const rectangle &cliprect)
499	497	{
500		cclimber_state *state = machine.driver_data<cclimber_state>();
501		UINT8 x = state->m_bigsprite_control[3] - 8;
502		UINT8 y = state->m_bigsprite_control[2];
503		int bigsprite_flip_x = (state->m_bigsprite_control[1] & 0x10) >> 4;
504		int bigsprite_flip_y = (state->m_bigsprite_control[1] & 0x20) >> 5;
	498	UINT8 x = m_bigsprite_control[3] - 8;
	499	UINT8 y = m_bigsprite_control[2];
	500	int bigsprite_flip_x = (m_bigsprite_control[1] & 0x10) >> 4;
	501	int bigsprite_flip_y = (m_bigsprite_control[1] & 0x20) >> 5;
505	502
506	503	if (bigsprite_flip_x)
507	504	x = 0x80 - x;
r20746	r20747
509	506	if (bigsprite_flip_y)
510	507	y = 0x80 - y;
511	508
512		state->m_bs_tilemap->mark_all_dirty();
	509	m_bs_tilemap->mark_all_dirty();
513	510
514		state->m_bs_tilemap->set_flip((bigsprite_flip_x ? TILEMAP_FLIPX : 0) |
	511	m_bs_tilemap->set_flip((bigsprite_flip_x ? TILEMAP_FLIPX : 0) |
515	512	(CCLIMBER_FLIP_Y ^ bigsprite_flip_y ? TILEMAP_FLIPY : 0));
516	513
517		state->m_bs_tilemap->set_scrollx(0, x);
518		state->m_bs_tilemap->set_scrolly(0, y);
	514	m_bs_tilemap->set_scrollx(0, x);
	515	m_bs_tilemap->set_scrolly(0, y);
519	516
520		state->m_bs_tilemap->draw(bitmap, cliprect, 0, 0);
	517	m_bs_tilemap->draw(bitmap, cliprect, 0, 0);
521	518	}
522	519
523	520
524		static void toprollr_draw_bigsprite(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	521	void cclimber_state::toprollr_draw_bigsprite(bitmap_ind16 &bitmap, const rectangle &cliprect)
525	522	{
526		cclimber_state *state = machine.driver_data<cclimber_state>();
527		UINT8 x = state->m_bigsprite_control[3] - 8;
528		UINT8 y = state->m_bigsprite_control[2];
	523	UINT8 x = m_bigsprite_control[3] - 8;
	524	UINT8 y = m_bigsprite_control[2];
529	525
530		state->m_bs_tilemap->mark_all_dirty();
	526	m_bs_tilemap->mark_all_dirty();
531	527
532		state->m_bs_tilemap->set_flip(CCLIMBER_FLIP_Y ? TILEMAP_FLIPY : 0);
	528	m_bs_tilemap->set_flip(CCLIMBER_FLIP_Y ? TILEMAP_FLIPY : 0);
533	529
534		state->m_bs_tilemap->set_scrollx(0, x);
535		state->m_bs_tilemap->set_scrolly(0, y);
	530	m_bs_tilemap->set_scrollx(0, x);
	531	m_bs_tilemap->set_scrolly(0, y);
536	532
537		state->m_bs_tilemap->draw(bitmap, cliprect, 0, 0);
	533	m_bs_tilemap->draw(bitmap, cliprect, 0, 0);
538	534	}
539	535
540	536
541		static void cclimber_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx)
	537	void cclimber_state::cclimber_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx)
542	538	{
543		cclimber_state *state = gfx->machine().driver_data<cclimber_state>();
544	539	int offs;
545	540
546	541	/* draw the sprites -- note that it is important to draw them exactly in this
547	542	order, to have the correct priorities. */
548	543	for (offs = 0x1c; offs >= 0; offs -= 4)
549	544	{
550		int x = state->m_spriteram[offs + 3] + 1;
	545	int x = m_spriteram[offs + 3] + 1;
551	546	/* x + 1 is evident in cclimber and ckong. It looks worse,
552	547	but it has been confirmed on several PCBs. */
553	548
554		int y = 240 - state->m_spriteram[offs + 2];
	549	int y = 240 - m_spriteram[offs + 2];
555	550
556		int code = ((state->m_spriteram[offs + 1] & 0x10) << 3) |
557		((state->m_spriteram[offs + 1] & 0x20) << 1) |
558		( state->m_spriteram[offs + 0] & 0x3f);
	551	int code = ((m_spriteram[offs + 1] & 0x10) << 3) |
	552	((m_spriteram[offs + 1] & 0x20) << 1) |
	553	( m_spriteram[offs + 0] & 0x3f);
559	554
560		int color = state->m_spriteram[offs + 1] & 0x0f;
	555	int color = m_spriteram[offs + 1] & 0x0f;
561	556
562		int flipx = state->m_spriteram[offs + 0] & 0x40;
563		int flipy = state->m_spriteram[offs + 0] & 0x80;
	557	int flipx = m_spriteram[offs + 0] & 0x40;
	558	int flipy = m_spriteram[offs + 0] & 0x80;
564	559
565	560	if (CCLIMBER_FLIP_X)
566	561	{
r20746	r20747
579	574	}
580	575
581	576
582		static void toprollr_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx)
	577	void cclimber_state::toprollr_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx)
583	578	{
584		cclimber_state *state = gfx->machine().driver_data<cclimber_state>();
585	579	int offs;
586	580
587	581	/* draw the sprites -- note that it is important to draw them exactly in this
588	582	order, to have the correct priorities. */
589	583	for (offs = 0x1c; offs >= 0; offs -= 4)
590	584	{
591		int x = state->m_spriteram[offs + 3];
592		int y = 240 - state->m_spriteram[offs + 2];
	585	int x = m_spriteram[offs + 3];
	586	int y = 240 - m_spriteram[offs + 2];
593	587
594		int code = ((state->m_spriteram[offs + 1] & 0x10) << 3) |
595		((state->m_spriteram[offs + 1] & 0x20) << 1) |
596		( state->m_spriteram[offs + 0] & 0x3f);
	588	int code = ((m_spriteram[offs + 1] & 0x10) << 3) |
	589	((m_spriteram[offs + 1] & 0x20) << 1) |
	590	( m_spriteram[offs + 0] & 0x3f);
597	591
598		int color = state->m_spriteram[offs + 1] & 0x0f;
	592	int color = m_spriteram[offs + 1] & 0x0f;
599	593
600		int flipx = state->m_spriteram[offs + 0] & 0x40;
601		int flipy = state->m_spriteram[offs + 0] & 0x80;
	594	int flipx = m_spriteram[offs + 0] & 0x40;
	595	int flipy = m_spriteram[offs + 0] & 0x80;
602	596
603	597	if (CCLIMBER_FLIP_X)
604	598	{
r20746	r20747
617	611	}
618	612
619	613
620		static void swimmer_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx)
	614	void cclimber_state::swimmer_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx)
621	615	{
622		cclimber_state *state = gfx->machine().driver_data<cclimber_state>();
623	616	int offs;
624	617
625	618	/* draw the sprites -- note that it is important to draw them exactly in this
626	619	order, to have the correct priorities. */
627	620	for (offs = 0x1c; offs >= 0; offs -= 4)
628	621	{
629		int x = state->m_spriteram[offs + 3];
630		int y = 240 - state->m_spriteram[offs + 2];
	622	int x = m_spriteram[offs + 3];
	623	int y = 240 - m_spriteram[offs + 2];
631	624
632		int code = ((state->m_spriteram[offs + 1] & 0x10) << 2) |
633		(state->m_spriteram[offs + 0] & 0x3f);
	625	int code = ((m_spriteram[offs + 1] & 0x10) << 2) |
	626	(m_spriteram[offs + 0] & 0x3f);
634	627
635		int color = ((*state->m_swimmer_palettebank & 0x01) << 4) |
636		(state->m_spriteram[offs + 1] & 0x0f);
	628	int color = ((*m_swimmer_palettebank & 0x01) << 4) |
	629	(m_spriteram[offs + 1] & 0x0f);
637	630
638		int flipx = state->m_spriteram[offs + 0] & 0x40;
639		int flipy = state->m_spriteram[offs + 0] & 0x80;
	631	int flipx = m_spriteram[offs + 0] & 0x40;
	632	int flipy = m_spriteram[offs + 0] & 0x80;
640	633
641	634	if (CCLIMBER_FLIP_X)
642	635	{
r20746	r20747
658	651	UINT32 cclimber_state::screen_update_cclimber(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
659	652	{
660	653	bitmap.fill(CCLIMBER_BG_PEN, cliprect);
661		draw_playfield(machine(), bitmap, cliprect);
	654	draw_playfield(bitmap, cliprect);
662	655
663	656	/* draw the "big sprite" under the regular sprites */
664	657	if ((m_bigsprite_control[0] & 0x01))
665	658	{
666		cclimber_draw_bigsprite(machine(), bitmap, cliprect);
	659	cclimber_draw_bigsprite(bitmap, cliprect);
667	660	cclimber_draw_sprites(bitmap, cliprect, machine().gfx[1]);
668	661	}
669	662
r20746	r20747
671	664	else
672	665	{
673	666	cclimber_draw_sprites(bitmap, cliprect, machine().gfx[1]);
674		cclimber_draw_bigsprite(machine(), bitmap, cliprect);
	667	cclimber_draw_bigsprite(bitmap, cliprect);
675	668	}
676	669
677	670	return 0;
r20746	r20747
680	673
681	674	UINT32 cclimber_state::screen_update_yamato(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
682	675	{
683		cclimber_state *state = machine().driver_data<cclimber_state>();
684	676	int i;
685	677	UINT8 *sky_rom = memregion("user1")->base() + 0x1200;
686	678
r20746	r20747
693	685	bitmap.pix16(j, (i - 8) & 0xff) = pen;
694	686	}
695	687
696		draw_playfield(machine(), bitmap, cliprect);
	688	draw_playfield(bitmap, cliprect);
697	689
698	690	/* draw the "big sprite" under the regular sprites */
699	691	if ((m_bigsprite_control[0] & 0x01))
700	692	{
701		cclimber_draw_bigsprite(machine(), bitmap, cliprect);
	693	cclimber_draw_bigsprite(bitmap, cliprect);
702	694	toprollr_draw_sprites(bitmap, cliprect, machine().gfx[1]);
703	695	}
704	696
r20746	r20747
706	698	else
707	699	{
708	700	toprollr_draw_sprites(bitmap, cliprect, machine().gfx[1]);
709		cclimber_draw_bigsprite(machine(), bitmap, cliprect);
	701	cclimber_draw_bigsprite(bitmap, cliprect);
710	702	}
711	703
712	704	return 0;
r20746	r20747
715	707
716	708	UINT32 cclimber_state::screen_update_swimmer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
717	709	{
718		cclimber_state *state = machine().driver_data<cclimber_state>();
719		swimmer_set_background_pen(machine());
	710	swimmer_set_background_pen();
720	711
721	712	if (*m_swimmer_side_background_enabled & 0x01)
722	713	{
r20746	r20747
746	737	else
747	738	bitmap.fill(CCLIMBER_BG_PEN, cliprect);
748	739
749		draw_playfield(machine(), bitmap, cliprect);
	740	draw_playfield(bitmap, cliprect);
750	741
751	742	/* draw the "big sprite" under the regular sprites */
752	743	if ((m_bigsprite_control[0] & 0x01))
753	744	{
754		cclimber_draw_bigsprite(machine(), bitmap, cliprect);
	745	cclimber_draw_bigsprite(bitmap, cliprect);
755	746	swimmer_draw_sprites(bitmap, cliprect, machine().gfx[1]);
756	747	}
757	748
r20746	r20747
759	750	else
760	751	{
761	752	swimmer_draw_sprites(bitmap, cliprect, machine().gfx[1]);
762		cclimber_draw_bigsprite(machine(), bitmap, cliprect);
	753	cclimber_draw_bigsprite(bitmap, cliprect);
763	754	}
764	755
765	756	return 0;
r20746	r20747
768	759
769	760	UINT32 cclimber_state::screen_update_toprollr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
770	761	{
771		cclimber_state *state = machine().driver_data<cclimber_state>();
772	762	rectangle scroll_area_clip = cliprect;
773	763	scroll_area_clip.min_x = 4*8;
774	764	scroll_area_clip.max_x = 29*8-1;
r20746	r20747
785	775	if ((m_bigsprite_control[1] & 0x20))
786	776	{
787	777	toprollr_draw_sprites(bitmap, scroll_area_clip, machine().gfx[1]);
788		toprollr_draw_bigsprite(machine(), bitmap, scroll_area_clip);
	778	toprollr_draw_bigsprite(bitmap, scroll_area_clip);
789	779	}
790	780
791	781	/* draw the "big sprite" under the regular sprites */
792	782	else
793	783	{
794		toprollr_draw_bigsprite(machine(), bitmap, scroll_area_clip);
	784	toprollr_draw_bigsprite(bitmap, scroll_area_clip);
795	785	toprollr_draw_sprites(bitmap, scroll_area_clip, machine().gfx[1]);
796	786	}
797	787

trunk/src/mame/video/cninja.c

r20746	r20747
23	23
24	24
25	25	/* The bootleg sprites are in a different format! */
26		static void cninjabl_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	26	void cninja_state::cninjabl_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
27	27	{
28		cninja_state *state = machine.driver_data<cninja_state>();
29		UINT16 *buffered_spriteram = state->m_spriteram->buffer();
	28	UINT16 *buffered_spriteram = m_spriteram->buffer();
30	29	int offs;
31	30	int endoffs;
32	31
r20746	r20747
66	65	}
67	66
68	67	flash = y & 0x1000;
69		if (flash && (machine.primary_screen->frame_number() & 1))
	68	if (flash && (machine().primary_screen->frame_number() & 1))
70	69	continue;
71	70
72	71	colour = (x >> 9) & 0x1f;
r20746	r20747
95	94	inc = 1;
96	95	}
97	96
98		if (state->flip_screen())
	97	if (flip_screen())
99	98	{
100	99	y = 240 - y;
101	100	x = 240 - x;
r20746	r20747
108	107
109	108	while (multi >= 0)
110	109	{
111		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[3],
	110	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[3],
112	111	sprite - multi * inc,
113	112	colour,
114	113	fx,fy,
115	114	x,y + mult * multi,
116		machine.priority_bitmap,pri,0);
	115	machine().priority_bitmap,pri,0);
117	116
118	117	multi--;
119	118	}
r20746	r20747
163	162	deco16ic_tilemap_1_draw(m_deco_tilegen2, bitmap, cliprect, 0, 2);
164	163	deco16ic_tilemap_2_draw(m_deco_tilegen1, bitmap, cliprect, TILEMAP_DRAW_LAYER1, 2);
165	164	deco16ic_tilemap_2_draw(m_deco_tilegen1, bitmap, cliprect, TILEMAP_DRAW_LAYER0, 4);
166		cninjabl_draw_sprites(machine(), bitmap, cliprect);
	165	cninjabl_draw_sprites(bitmap, cliprect);
167	166	deco16ic_tilemap_1_draw(m_deco_tilegen1, bitmap, cliprect, 0, 0);
168	167	return 0;
169	168	}

trunk/src/mame/video/canyon.c

r20746	r20747
29	29	}
30	30
31	31
32		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	32	void canyon_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
33	33	{
34		canyon_state *state = machine.driver_data<canyon_state>();
35	34	int i;
36	35
37	36	for (i = 0; i < 2; i++)
38	37	{
39		int x = state->m_videoram[0x3d0 + 2 * i + 0x1];
40		int y = state->m_videoram[0x3d0 + 2 * i + 0x8];
41		int c = state->m_videoram[0x3d0 + 2 * i + 0x9];
	38	int x = m_videoram[0x3d0 + 2 * i + 0x1];
	39	int y = m_videoram[0x3d0 + 2 * i + 0x8];
	40	int c = m_videoram[0x3d0 + 2 * i + 0x9];
42	41
43	42	drawgfx_transpen(bitmap, cliprect,
44		machine.gfx[1],
	43	machine().gfx[1],
45	44	c >> 3,
46	45	i,
47	46	!(c & 0x80), 0,
r20746	r20747
51	50	}
52	51
53	52
54		static void draw_bombs( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	53	void canyon_state::draw_bombs( bitmap_ind16 &bitmap, const rectangle &cliprect )
55	54	{
56		canyon_state *state = machine.driver_data<canyon_state>();
57	55	int i;
58	56
59	57	for (i = 0; i < 2; i++)
60	58	{
61		int sx = 254 - state->m_videoram[0x3d0 + 2 * i + 0x5];
62		int sy = 246 - state->m_videoram[0x3d0 + 2 * i + 0xc];
	59	int sx = 254 - m_videoram[0x3d0 + 2 * i + 0x5];
	60	int sy = 246 - m_videoram[0x3d0 + 2 * i + 0xc];
63	61
64	62	rectangle rect(sx, sx + 1, sy, sy + 1);
65	63	rect &= cliprect;
r20746	r20747
73	71	{
74	72	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
75	73
76		draw_sprites(machine(), bitmap, cliprect);
	74	draw_sprites(bitmap, cliprect);
77	75
78		draw_bombs(machine(), bitmap, cliprect);
	76	draw_bombs(bitmap, cliprect);
79	77
80	78	/* watchdog is disabled during service mode */
81	79	machine().watchdog_enable(!(machine().root_device().ioport("IN2")->read() & 0x10));

trunk/src/mame/video/cabal.c

r20746	r20747
96	96
97	97	********************************************************************/
98	98
99		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	99	void cabal_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
100	100	{
101		cabal_state *state = machine.driver_data<cabal_state>();
102	101	int offs,data0,data1,data2;
103		UINT16 *spriteram16 = state->m_spriteram;
	102	UINT16 *spriteram16 = m_spriteram;
104	103
105		for( offs = state->m_spriteram.bytes()/2 - 4; offs >= 0; offs -= 4 )
	104	for( offs = m_spriteram.bytes()/2 - 4; offs >= 0; offs -= 4 )
106	105	{
107	106	data0 = spriteram16[offs];
108	107	data1 = spriteram16[offs+1];
r20746	r20747
119	118
120	119	if ( sx>256 )   sx -= 512;
121	120
122		if (state->flip_screen())
	121	if (flip_screen())
123	122	{
124	123	sx = 240 - sx;
125	124	sy = 240 - sy;
r20746	r20747
127	126	flipy = !flipy;
128	127	}
129	128
130		drawgfx_transpen( bitmap,cliprect,machine.gfx[2],
	129	drawgfx_transpen( bitmap,cliprect,machine().gfx[2],
131	130	tile_number,
132	131	color,
133	132	flipx,flipy,
r20746	r20747
140	139	UINT32 cabal_state::screen_update_cabal(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
141	140	{
142	141	m_background_layer->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE,0);
143		draw_sprites(machine(),bitmap,cliprect);
	142	draw_sprites(bitmap,cliprect);
144	143	m_text_layer->draw(bitmap, cliprect, 0,0);
145	144	return 0;
146	145	}

trunk/src/mame/video/circusc.c

r20746	r20747
158	158
159	159	***************************************************************************/
160	160
161		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	161	void circusc_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
162	162	{
163		circusc_state *state = machine.driver_data<circusc_state>();
164	163	int offs;
165	164	UINT8 *sr;
166	165
167		if ((*state->m_spritebank & 0x01) != 0)
168		sr = state->m_spriteram;
	166	if ((*m_spritebank & 0x01) != 0)
	167	sr = m_spriteram;
169	168	else
170		sr = state->m_spriteram_2;
	169	sr = m_spriteram_2;
171	170
172		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 4)
	171	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
173	172	{
174	173	int code = sr[offs + 0] + 8 * (sr[offs + 1] & 0x20);
175	174	int color = sr[offs + 1] & 0x0f;
r20746	r20747
178	177	int flipx = sr[offs + 1] & 0x40;
179	178	int flipy = sr[offs + 1] & 0x80;
180	179
181		if (state->flip_screen())
	180	if (flip_screen())
182	181	{
183	182	sx = 240 - sx;
184	183	sy = 240 - sy;
r20746	r20747
187	186	}
188	187
189	188
190		drawgfx_transmask(bitmap,cliprect,machine.gfx[1],
	189	drawgfx_transmask(bitmap,cliprect,machine().gfx[1],
191	190	code, color,
192	191	flipx,flipy,
193	192	sx,sy,
194		colortable_get_transpen_mask(machine.colortable, machine.gfx[1], color, 0));
	193	colortable_get_transpen_mask(machine().colortable, machine().gfx[1], color, 0));
195	194	}
196	195	}
197	196
r20746	r20747
206	205
207	206	bitmap.fill(0, cliprect);
208	207	m_bg_tilemap->draw(bitmap, cliprect, 1, 0);
209		draw_sprites(machine(), bitmap, cliprect);
	208	draw_sprites(bitmap, cliprect);
210	209	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
211	210	return 0;
212	211	}

trunk/src/mame/video/crgolf.c

r20746	r20747
47	47	*
48	48	*************************************/
49	49
50		static void get_pens( running_machine &machine, pen_t *pens )
	50	void crgolf_state::get_pens( pen_t *pens )
51	51	{
52	52	offs_t offs;
53		const UINT8 *prom = machine.root_device().memregion("proms")->base();
	53	const UINT8 *prom = machine().root_device().memregion("proms")->base();
54	54
55	55	for (offs = 0; offs < NUM_PENS; offs++)
56	56	{
r20746	r20747
113	113	offs_t offs;
114	114	pen_t pens[NUM_PENS];
115	115
116		get_pens(machine(), pens);
	116	get_pens(pens);
117	117
118	118	/* for each byte in the video RAM */
119	119	for (offs = 0; offs < VIDEORAM_SIZE / 3; offs++)

trunk/src/mame/video/cbuster.c

r20746	r20747
12	12
13	13	/* maybe the game should just use generic palette handling, and have a darker palette by design... */
14	14
15		static void update_24bitcol( running_machine &machine, int offset )
	15	void cbuster_state::update_24bitcol( int offset )
16	16	{
17		cbuster_state *state = machine.driver_data<cbuster_state>();
18	17	UINT8 r, g, b; /* The highest palette value seems to be 0x8e */
19	18
20		r = (UINT8)((float)((state->m_generic_paletteram_16[offset]  >> 0) & 0xff) * 1.75);
21		g = (UINT8)((float)((state->m_generic_paletteram_16[offset]  >> 8) & 0xff) * 1.75);
22		b = (UINT8)((float)((state->m_generic_paletteram2_16[offset] >> 0) & 0xff) * 1.75);
	19	r = (UINT8)((float)((m_generic_paletteram_16[offset]  >> 0) & 0xff) * 1.75);
	20	g = (UINT8)((float)((m_generic_paletteram_16[offset]  >> 8) & 0xff) * 1.75);
	21	b = (UINT8)((float)((m_generic_paletteram2_16[offset] >> 0) & 0xff) * 1.75);
23	22
24		palette_set_color(machine, offset, MAKE_RGB(r, g, b));
	23	palette_set_color(machine(), offset, MAKE_RGB(r, g, b));
25	24	}
26	25
27	26	WRITE16_MEMBER(cbuster_state::twocrude_palette_24bit_rg_w)
28	27	{
29	28	COMBINE_DATA(&m_generic_paletteram_16[offset]);
30		update_24bitcol(machine(), offset);
	29	update_24bitcol(offset);
31	30	}
32	31
33	32	WRITE16_MEMBER(cbuster_state::twocrude_palette_24bit_b_w)
34	33	{
35	34	COMBINE_DATA(&m_generic_paletteram2_16[offset]);
36		update_24bitcol(machine(), offset);
	35	update_24bitcol(offset);
37	36	}
38	37
39	38

trunk/src/mame/video/compgolf.c

r20746	r20747
86	86	-----x-- -------- -------- -------- Flip X
87	87	-------- -------- -------- -------- Flip Y(used?)
88	88	*/
89		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	89	void compgolf_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
90	90	{
91		compgolf_state *state = machine.driver_data<compgolf_state>();
92	91	int offs, fx, fy, x, y, color, sprite;
93	92
94	93	for (offs = 0; offs < 0x60; offs += 4)
95	94	{
96		sprite = state->m_spriteram[offs + 1] + (((state->m_spriteram[offs] & 0xc0) >> 6) * 0x100);
97		x = 240 - state->m_spriteram[offs + 3];
98		y = state->m_spriteram[offs + 2];
99		color = (state->m_spriteram[offs] & 8)>>3;
100		fx = state->m_spriteram[offs] & 4;
	95	sprite = m_spriteram[offs + 1] + (((m_spriteram[offs] & 0xc0) >> 6) * 0x100);
	96	x = 240 - m_spriteram[offs + 3];
	97	y = m_spriteram[offs + 2];
	98	color = (m_spriteram[offs] & 8)>>3;
	99	fx = m_spriteram[offs] & 4;
101	100	fy = 0; /* ? */
102	101
103		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	102	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
104	103	sprite,
105	104	color,fx,fy,x,y,0);
106	105
107	106	/* Double Height */
108		if(state->m_spriteram[offs] & 0x10)
	107	if(m_spriteram[offs] & 0x10)
109	108	{
110		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	109	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
111	110	sprite + 1,
112	111	color, fx, fy, x, y + 16, 0);
113	112	}
r20746	r20747
124	123
125	124	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
126	125	m_text_tilemap->draw(bitmap, cliprect, 0, 0);
127		draw_sprites(machine(), bitmap, cliprect);
	126	draw_sprites(bitmap, cliprect);
128	127	return 0;
129	128	}

trunk/src/mame/video/galaxia.c

r20746	r20747
76	76	SET_TILE_INFO_MEMBER(0, code, color, 0);
77	77	}
78	78
79		static void init_common( running_machine &machine )
	79	void galaxia_state::init_common()
80	80	{
81	81	assert((STAR_PEN & 7) == 0);
82		cvs_init_stars(machine);
	82	cvs_init_stars();
83	83	}
84	84
85	85	VIDEO_START_MEMBER(galaxia_state,galaxia)
86	86	{
87		init_common(machine());
	87	init_common();
88	88
89	89	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(galaxia_state::get_galaxia_bg_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
90	90	m_bg_tilemap->set_transparent_pen(0);
r20746	r20747
94	94
95	95	VIDEO_START_MEMBER(galaxia_state,astrowar)
96	96	{
97		init_common(machine());
	97	init_common();
98	98
99	99	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(galaxia_state::get_astrowar_bg_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
100	100	m_bg_tilemap->set_transparent_pen(0);
r20746	r20747
116	116	bitmap_ind16 &s2636_2_bitmap = s2636_update(machine().device("s2636_2"), cliprect);
117	117
118	118	bitmap.fill(0, cliprect);
119		cvs_update_stars(machine(), bitmap, cliprect, STAR_PEN, 1);
	119	cvs_update_stars(bitmap, cliprect, STAR_PEN, 1);
120	120	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
121	121
122	122	for (y = cliprect.min_y; y <= cliprect.max_y; y++)
r20746	r20747
180	180	bitmap_ind16 &s2636_0_bitmap = s2636_update(machine().device("s2636_0"), cliprect);
181	181
182	182	bitmap.fill(0, cliprect);
183		cvs_update_stars(machine(), bitmap, cliprect, STAR_PEN, 1);
	183	cvs_update_stars(bitmap, cliprect, STAR_PEN, 1);
184	184	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
185	185	copybitmap(m_temp_bitmap, bitmap, 0, 0, 0, 0, cliprect);
186	186

trunk/src/mame/video/cbasebal.c

r20746	r20747
130	130
131	131	***************************************************************************/
132	132
133		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	133	void cbasebal_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
134	134	{
135		cbasebal_state *state = machine.driver_data<cbasebal_state>();
136		UINT8 *spriteram = state->m_spriteram;
	135	UINT8 *spriteram = m_spriteram;
137	136	int offs, sx, sy;
138	137
139	138	/* the last entry is not a sprite, we skip it otherwise spang shows a bubble */
140	139	/* moving diagonally across the screen */
141		for (offs = state->m_spriteram.bytes() - 8; offs >= 0; offs -= 4)
	140	for (offs = m_spriteram.bytes() - 8; offs >= 0; offs -= 4)
142	141	{
143	142	int code = spriteram[offs];
144	143	int attr = spriteram[offs + 1];
r20746	r20747
147	146	sx = spriteram[offs + 3] + ((attr & 0x10) << 4);
148	147	sy = ((spriteram[offs + 2] + 8) & 0xff) - 8;
149	148	code += (attr & 0xe0) << 3;
150		code += state->m_spritebank * 0x800;
	149	code += m_spritebank * 0x800;
151	150
152		if (state->m_flipscreen)
	151	if (m_flipscreen)
153	152	{
154	153	sx = 496 - sx;
155	154	sy = 240 - sy;
156	155	flipx = !flipx;
157	156	}
158	157
159		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	158	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
160	159	code,
161	160	color,
162		flipx,state->m_flipscreen,
	161	flipx,m_flipscreen,
163	162	sx,sy,15);
164	163	}
165	164	}
r20746	r20747
172	171	bitmap.fill(768, cliprect);
173	172
174	173	if (m_obj_on)
175		draw_sprites(machine(), bitmap, cliprect);
	174	draw_sprites(bitmap, cliprect);
176	175
177	176	if (m_text_on)
178	177	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);

trunk/src/mame/video/crbaloon.c

r20746	r20747
76	76	}
77	77
78	78
79		UINT16 crbaloon_get_collision_address(running_machine &machine)
	79	UINT16 crbaloon_state::crbaloon_get_collision_address()
80	80	{
81		crbaloon_state *state = machine.driver_data<crbaloon_state>();
82		return state->m_collision_address_clear ? 0xffff : state->m_collision_address;
	81	return m_collision_address_clear ? 0xffff : m_collision_address;
83	82	}
84	83
85	84
86		void crbaloon_set_clear_collision_address(running_machine &machine, int _crbaloon_collision_address_clear)
	85	void crbaloon_state::crbaloon_set_clear_collision_address(int _crbaloon_collision_address_clear)
87	86	{
88		crbaloon_state *state = machine.driver_data<crbaloon_state>();
89		state->m_collision_address_clear = !_crbaloon_collision_address_clear; /* active LO */
	87	m_collision_address_clear = !_crbaloon_collision_address_clear; /* active LO */
90	88	}
91	89
92	90
93	91
94		static void draw_sprite_and_check_collision(running_machine &machine, bitmap_ind16 &bitmap)
	92	void crbaloon_state::draw_sprite_and_check_collision(bitmap_ind16 &bitmap)
95	93	{
96		crbaloon_state *state = machine.driver_data<crbaloon_state>();
97	94	int y;
98		UINT8 code = state->m_spriteram[0] & 0x0f;
99		UINT8 color = state->m_spriteram[0] >> 4;
100		UINT8 sy = state->m_spriteram[2] - 32;
	95	UINT8 code = m_spriteram[0] & 0x0f;
	96	UINT8 color = m_spriteram[0] >> 4;
	97	UINT8 sy = m_spriteram[2] - 32;
101	98
102		UINT8 *gfx = state->memregion("gfx2")->base() + (code << 7);
	99	UINT8 *gfx = memregion("gfx2")->base() + (code << 7);
103	100
104	101
105		if (state->flip_screen())
	102	if (flip_screen())
106	103	sy += 32;
107	104
108	105	/* assume no collision */
109		state->m_collision_address = 0xffff;
	106	m_collision_address = 0xffff;
110	107
111	108	for (y = 0x1f; y >= 0; y--)
112	109	{
113	110	int x;
114	111	UINT8 data = 0;
115		UINT8 sx = state->m_spriteram[1];
	112	UINT8 sx = m_spriteram[1];
116	113
117	114	for (x = 0x1f; x >= 0; x--)
118	115	{
r20746	r20747
130	127	if (bitmap.pix16(sy, sx) & 0x01)
131	128	/* compute the collision address -- the +1 is via observation
132	129	of the game code, probably wrong for cocktail mode */
133		state->m_collision_address = ((((sy ^ 0xff) >> 3) << 5) | ((sx ^ 0xff) >> 3)) + 1;
	130	m_collision_address = ((((sy ^ 0xff) >> 3) << 5) | ((sx ^ 0xff) >> 3)) + 1;
134	131
135	132	bitmap.pix16(sy, sx) = (color << 1) | 1;
136	133	}
r20746	r20747
148	145	{
149	146	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
150	147
151		draw_sprite_and_check_collision(machine(), bitmap);
	148	draw_sprite_and_check_collision(bitmap);
152	149
153	150	return 0;
154	151	}

trunk/src/mame/video/cischeat.c

r20746	r20747
111	111
112	112	***************************************************************************/
113	113
114		static void prepare_shadows(cischeat_state *state)
	114	void cischeat_state::prepare_shadows(cischeat_state *state)
115	115	{
116	116	int i;
117	117	for (i = 0;i < 16;i++)
118		state->m_drawmode_table[i] = DRAWMODE_SOURCE;
	118	m_drawmode_table[i] = DRAWMODE_SOURCE;
119	119
120		state->m_drawmode_table[ 0] = DRAWMODE_SHADOW;
121		state->m_drawmode_table[15] = DRAWMODE_NONE;
	120	m_drawmode_table[ 0] = DRAWMODE_SHADOW;
	121	m_drawmode_table[15] = DRAWMODE_NONE;
122	122	}
123	123
124	124	/**************************************************************************
r20746	r20747
129	129	#define TILES_PER_PAGE_Y (0x20)
130	130	#define TILES_PER_PAGE (TILES_PER_PAGE_X * TILES_PER_PAGE_Y)
131	131
132		INLINE void scrollram_w(address_space &space, offs_t offset, UINT16 data, UINT16 mem_mask, int which)
	132	inline void cischeat_state::scrollram_w(address_space &space, offs_t offset, UINT16 data, UINT16 mem_mask, int which)
133	133	{
134		cischeat_state *state = space.machine().driver_data<cischeat_state>();
135		COMBINE_DATA(&state->m_scrollram[which][offset]);
136		if (offset < 0x40000/2 && state->m_tmap[which])
	134	COMBINE_DATA(&m_scrollram[which][offset]);
	135	if (offset < 0x40000/2 && m_tmap[which])
137	136	{
138		if (state->m_scroll_flag[which] & 0x10) /* tiles are 8x8 */
	137	if (m_scroll_flag[which] & 0x10) /* tiles are 8x8 */
139	138	{
140		state->m_tmap[which]->mark_tile_dirty(offset);
	139	m_tmap[which]->mark_tile_dirty(offset);
141	140	}
142	141	else
143	142	{
144		state->m_tmap[which]->mark_tile_dirty(offset*4 + 0);
145		state->m_tmap[which]->mark_tile_dirty(offset*4 + 1);
146		state->m_tmap[which]->mark_tile_dirty(offset*4 + 2);
147		state->m_tmap[which]->mark_tile_dirty(offset*4 + 3);
	143	m_tmap[which]->mark_tile_dirty(offset*4 + 0);
	144	m_tmap[which]->mark_tile_dirty(offset*4 + 1);
	145	m_tmap[which]->mark_tile_dirty(offset*4 + 2);
	146	m_tmap[which]->mark_tile_dirty(offset*4 + 3);
148	147	}
149	148	}
150	149	}
r20746	r20747
181	180	SET_TILE_INFO_MEMBER(tmap, (code & 0xfff) * 4 + (tile_index & 3), code >> (16 - m_bits_per_color_code), 0);
182	181	}
183	182
184		static void create_tilemaps(running_machine &machine)
	183	void cischeat_state::create_tilemaps()
185	184	{
186		cischeat_state *state = machine.driver_data<cischeat_state>();
187	185	int layer, i;
188	186
189	187	for (layer = 0; layer < 3; layer++)
190	188	{
191	189	/* 16x16 tilemaps */
192		state->m_tilemap[layer][0][0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_16x16),state), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_16x16),state),
	190	m_tilemap[layer][0][0] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_16x16),this), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_16x16),this),
193	191	8,8, TILES_PER_PAGE_X * 16, TILES_PER_PAGE_Y * 2);
194		state->m_tilemap[layer][0][1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_16x16),state), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_16x16),state),
	192	m_tilemap[layer][0][1] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_16x16),this), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_16x16),this),
195	193	8,8, TILES_PER_PAGE_X * 8, TILES_PER_PAGE_Y * 4);
196		state->m_tilemap[layer][0][2] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_16x16),state), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_16x16),state),
	194	m_tilemap[layer][0][2] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_16x16),this), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_16x16),this),
197	195	8,8, TILES_PER_PAGE_X * 4, TILES_PER_PAGE_Y * 8);
198		state->m_tilemap[layer][0][3] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_16x16),state), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_16x16),state),
	196	m_tilemap[layer][0][3] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_16x16),this), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_16x16),this),
199	197	8,8, TILES_PER_PAGE_X * 2, TILES_PER_PAGE_Y * 16);
200	198
201	199	/* 8x8 tilemaps */
202		state->m_tilemap[layer][1][0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_8x8),state), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_8x8),state),
	200	m_tilemap[layer][1][0] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_8x8),this), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_8x8),this),
203	201	8,8, TILES_PER_PAGE_X * 8, TILES_PER_PAGE_Y * 1);
204		state->m_tilemap[layer][1][1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_8x8),state), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_8x8),state),
	202	m_tilemap[layer][1][1] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_8x8),this), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_8x8),this),
205	203	8,8, TILES_PER_PAGE_X * 4, TILES_PER_PAGE_Y * 2);
206		state->m_tilemap[layer][1][2] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_8x8),state), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_8x8),state),
	204	m_tilemap[layer][1][2] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_8x8),this), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_8x8),this),
207	205	8,8, TILES_PER_PAGE_X * 4, TILES_PER_PAGE_Y * 2);
208		state->m_tilemap[layer][1][3] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_8x8),state), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_8x8),state),
	206	m_tilemap[layer][1][3] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(cischeat_state::cischeat_get_scroll_tile_info_8x8),this), tilemap_mapper_delegate(FUNC(cischeat_state::cischeat_scan_8x8),this),
209	207	8,8, TILES_PER_PAGE_X * 2, TILES_PER_PAGE_Y * 4);
210	208
211	209	/* set user data and transparency */
212	210	for (i = 0; i < 8; i++)
213	211	{
214		state->m_tilemap[layer][i/4][i%4]->set_user_data((void *)(FPTR)layer);
215		state->m_tilemap[layer][i/4][i%4]->set_transparent_pen(15);
	212	m_tilemap[layer][i/4][i%4]->set_user_data((void *)(FPTR)layer);
	213	m_tilemap[layer][i/4][i%4]->set_transparent_pen(15);
216	214	}
217	215	}
218	216	}
r20746	r20747
234	232
235	233	m_spriteram = &m_ram[0x8000/2];
236	234
237		create_tilemaps(machine());
	235	create_tilemaps();
238	236	m_tmap[0] = m_tilemap[0][0][0];
239	237	m_tmap[1] = m_tilemap[1][0][0];
240	238	m_tmap[2] = m_tilemap[2][0][0];
r20746	r20747
700	698	/*  Draw the road in the given bitmap. The priority1 and priority2 parameters
701	699	specify the range of lines to draw  */
702	700
703		static void cischeat_draw_road(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int road_num, int priority1, int priority2, int transparency)
	701	void cischeat_state::cischeat_draw_road(bitmap_ind16 &bitmap, const rectangle &cliprect, int road_num, int priority1, int priority2, int transparency)
704	702	{
705		cischeat_state *state = machine.driver_data<cischeat_state>();
706	703	int curr_code,sx,sy;
707	704	int min_priority, max_priority;
708	705
709	706	rectangle rect      =   cliprect;
710		gfx_element *gfx        =   machine.gfx[(road_num & 1)?5:4];
	707	gfx_element *gfx        =   machine().gfx[(road_num & 1)?5:4];
711	708
712		UINT16 *roadram         =   state->m_roadram[road_num & 1];
	709	UINT16 *roadram         =   m_roadram[road_num & 1];
713	710
714	711	int min_y = rect.min_y;
715	712	int max_y = rect.max_y;
r20746	r20747
790	787	/*  Draw the road in the given bitmap. The priority1 and priority2 parameters
791	788	specify the range of lines to draw  */
792	789
793		static void f1gpstar_draw_road(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int road_num, int priority1, int priority2, int transparency)
	790	void cischeat_state::f1gpstar_draw_road(bitmap_ind16 &bitmap, const rectangle &cliprect, int road_num, int priority1, int priority2, int transparency)
794	791	{
795		cischeat_state *state = machine.driver_data<cischeat_state>();
796	792	int sx,sy;
797	793	int xstart;
798	794	int min_priority, max_priority;
799	795
800	796	rectangle rect      =   cliprect;
801		gfx_element *gfx        =   machine.gfx[(road_num & 1)?5:4];
	797	gfx_element *gfx        =   machine().gfx[(road_num & 1)?5:4];
802	798
803		UINT16 *roadram         =   state->m_roadram[road_num & 1];
	799	UINT16 *roadram         =   m_roadram[road_num & 1];
804	800
805	801	int min_y = rect.min_y;
806	802	int max_y = rect.max_y;
r20746	r20747
906	902	sprites whose priority nibble is between 0 and 15 and whose
907	903	colour code's high bit is set.  */
908	904
909		static void cischeat_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap , const rectangle &cliprect, int priority1, int priority2)
	905	void cischeat_state::cischeat_draw_sprites(bitmap_ind16 &bitmap , const rectangle &cliprect, int priority1, int priority2)
910	906	{
911		cischeat_state *state = machine.driver_data<cischeat_state>();
912	907	int x, sx, flipx, xzoom, xscale, xdim, xnum, xstart, xend, xinc;
913	908	int y, sy, flipy, yzoom, yscale, ydim, ynum, ystart, yend, yinc;
914	909	int code, attr, color, size, shadow;
915	910
916	911	int min_priority, max_priority, high_sprites;
917	912
918		UINT16      *source =   state->m_spriteram;
	913	UINT16      *source =   m_spriteram;
919	914	const UINT16    *finish =   source + 0x1000/2;
920	915
921	916
r20746	r20747
952	947
953	948	/* dimension of a tile after zoom */
954	949	#ifdef MAME_DEBUG
955		if ( machine.input().code_pressed(KEYCODE_Z) && machine.input().code_pressed(KEYCODE_M) )
	950	if ( machine().input().code_pressed(KEYCODE_Z) && machine().input().code_pressed(KEYCODE_M) )
956	951	{
957	952	xdim    =   16 << 16;
958	953	ydim    =   16 << 16;
r20746	r20747
983	978	continue;
984	979
985	980	#ifdef MAME_DEBUG
986		if ( (state->m_debugsprites) && ( ((attr & 0x0300)>>8) != (state->m_debugsprites-1) ) ) { continue; };
	981	if ( (m_debugsprites) && ( ((attr & 0x0300)>>8) != (m_debugsprites-1) ) ) { continue; };
987	982	#endif
988	983
989	984	xscale = xdim / 16;
r20746	r20747
1002	997	if (flipy)  { ystart = ynum-1;  yend = -1;    yinc = -1; }
1003	998	else        { ystart = 0;       yend = ynum;  yinc = +1; }
1004	999
1005		state->m_drawmode_table[ 0] = shadow ? DRAWMODE_SHADOW : DRAWMODE_SOURCE;
	1000	m_drawmode_table[ 0] = shadow ? DRAWMODE_SHADOW : DRAWMODE_SOURCE;
1006	1001
1007	1002	for (y = ystart; y != yend; y += yinc)
1008	1003	{
1009	1004	for (x = xstart; x != xend; x += xinc)
1010	1005	{
1011		drawgfxzoom_transtable(bitmap,cliprect,machine.gfx[3],
	1006	drawgfxzoom_transtable(bitmap,cliprect,machine().gfx[3],
1012	1007	code++,
1013	1008	color,
1014	1009	flipx,flipy,
1015	1010	(sx + x * xdim) / 0x10000, (sy + y * ydim) / 0x10000,
1016		xscale, yscale, state->m_drawmode_table, machine.shadow_table);
	1011	xscale, yscale, m_drawmode_table, machine().shadow_table);
1017	1012	}
1018	1013	}
1019	1014	#ifdef MAME_DEBUG
1020	1015	#if 0
1021		if (machine.input().code_pressed(KEYCODE_X))
	1016	if (machine().input().code_pressed(KEYCODE_X))
1022	1017	{   /* Display some info on each sprite */
1023	1018	sprintf(buf, "%04x",attr);
1024	1019	ui_draw_text(buf, sx>>16, sy>>16);
r20746	r20747
1062	1057
1063	1058	***************************************************************************/
1064	1059
1065		static void bigrun_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap , const rectangle &cliprect, int priority1, int priority2)
	1060	void cischeat_state::bigrun_draw_sprites(bitmap_ind16 &bitmap , const rectangle &cliprect, int priority1, int priority2)
1066	1061	{
1067		cischeat_state *state = machine.driver_data<cischeat_state>();
1068	1062	int x, sx, flipx, xzoom, xscale, xdim, xnum, xstart, xend, xinc;
1069	1063	int y, sy, flipy, yzoom, yscale, ydim, ynum, ystart, yend, yinc;
1070	1064	int code, attr, color, size, shadow;
1071	1065
1072	1066	int min_priority, max_priority, high_sprites;
1073	1067
1074		UINT16      *source =   state->m_spriteram;
	1068	UINT16      *source =   m_spriteram;
1075	1069	const UINT16    *finish =   source + 0x1000/2;
1076	1070
1077	1071	/* Move the priority values in place */
r20746	r20747
1109	1103
1110	1104	/* dimension of a tile after zoom */
1111	1105	#ifdef MAME_DEBUG
1112		if ( machine.input().code_pressed(KEYCODE_Z) && machine.input().code_pressed(KEYCODE_M) )
	1106	if ( machine().input().code_pressed(KEYCODE_Z) && machine().input().code_pressed(KEYCODE_M) )
1113	1107	{
1114	1108	xdim    =   16 << 16;
1115	1109	ydim    =   16 << 16;
r20746	r20747
1138	1132	continue;
1139	1133
1140	1134	#ifdef MAME_DEBUG
1141		if ( (state->m_debugsprites) && ( ((attr & 0x0300)>>8) != (state->m_debugsprites-1) ) ) { continue; };
	1135	if ( (m_debugsprites) && ( ((attr & 0x0300)>>8) != (m_debugsprites-1) ) ) { continue; };
1142	1136	#endif
1143	1137
1144	1138	xscale = xdim / 16;
r20746	r20747
1157	1151	if (flipy)  { ystart = ynum-1;  yend = -1;    yinc = -1; }
1158	1152	else        { ystart = 0;       yend = ynum;  yinc = +1; }
1159	1153
1160		state->m_drawmode_table[ 0] = shadow ? DRAWMODE_SHADOW : DRAWMODE_SOURCE;
	1154	m_drawmode_table[ 0] = shadow ? DRAWMODE_SHADOW : DRAWMODE_SOURCE;
1161	1155
1162	1156	for (y = ystart; y != yend; y += yinc)
1163	1157	{
1164	1158	for (x = xstart; x != xend; x += xinc)
1165	1159	{
1166		drawgfxzoom_transtable(bitmap,cliprect,machine.gfx[3],
	1160	drawgfxzoom_transtable(bitmap,cliprect,machine().gfx[3],
1167	1161	code++,
1168	1162	color,
1169	1163	flipx,flipy,
1170	1164	(sx + x * xdim) / 0x10000, (sy + y * ydim) / 0x10000,
1171		xscale, yscale, state->m_drawmode_table, machine.shadow_table);
	1165	xscale, yscale, m_drawmode_table, machine().shadow_table);
1172	1166	}
1173	1167	}
1174	1168	#ifdef MAME_DEBUG
1175	1169	#if 0
1176		if (machine.input().code_pressed(KEYCODE_X))
	1170	if (machine().input().code_pressed(KEYCODE_X))
1177	1171	{   /* Display some info on each sprite */
1178	1172	sprintf(buf, "%04x",attr);
1179	1173	ui_draw_text(buf, sx>>16, sy>>16);
r20746	r20747
1253	1247
1254	1248	for (i = 7; i >= 4; i--)
1255	1249	{                                           /* bitmap, road, min_priority, max_priority, transparency */
1256		if (m_active_layers & 0x10) cischeat_draw_road(machine(),bitmap,cliprect,0,i,i,FALSE);
1257		if (m_active_layers & 0x20) cischeat_draw_road(machine(),bitmap,cliprect,1,i,i,TRUE);
	1250	if (m_active_layers & 0x10) cischeat_draw_road(bitmap,cliprect,0,i,i,FALSE);
	1251	if (m_active_layers & 0x20) cischeat_draw_road(bitmap,cliprect,1,i,i,TRUE);
1258	1252	}
1259	1253
1260	1254	flag = 0;
r20746	r20747
1263	1257
1264	1258	for (i = 3; i >= 0; i--)
1265	1259	{                                           /* bitmap, road, min_priority, max_priority, transparency */
1266		if (m_active_layers & 0x10) cischeat_draw_road(machine(),bitmap,cliprect,0,i,i,TRUE);
1267		if (m_active_layers & 0x20) cischeat_draw_road(machine(),bitmap,cliprect,1,i,i,TRUE);
	1260	if (m_active_layers & 0x10) cischeat_draw_road(bitmap,cliprect,0,i,i,TRUE);
	1261	if (m_active_layers & 0x20) cischeat_draw_road(bitmap,cliprect,1,i,i,TRUE);
1268	1262	}
1269	1263
1270		if (m_active_layers & 0x08) bigrun_draw_sprites(machine(),bitmap,cliprect,15,0);
	1264	if (m_active_layers & 0x08) bigrun_draw_sprites(bitmap,cliprect,15,0);
1271	1265
1272	1266	cischeat_tmap_DRAW(2)
1273	1267
r20746	r20747
1305	1299	bitmap.fill(0, cliprect);
1306	1300
1307	1301	/* bitmap, road, priority, transparency */
1308		if (m_active_layers & 0x10) cischeat_draw_road(machine(),bitmap,cliprect,0,7,5,FALSE);
1309		if (m_active_layers & 0x20) cischeat_draw_road(machine(),bitmap,cliprect,1,7,5,TRUE);
	1302	if (m_active_layers & 0x10) cischeat_draw_road(bitmap,cliprect,0,7,5,FALSE);
	1303	if (m_active_layers & 0x20) cischeat_draw_road(bitmap,cliprect,1,7,5,TRUE);
1310	1304
1311	1305	flag = 0;
1312	1306	cischeat_tmap_DRAW(0)
1313	1307	//  else bitmap.fill(0, cliprect);
1314	1308	cischeat_tmap_DRAW(1)
1315	1309
1316		if (m_active_layers & 0x08) cischeat_draw_sprites(machine(),bitmap,cliprect,15,3);
1317		if (m_active_layers & 0x10) cischeat_draw_road(machine(),bitmap,cliprect,0,4,1,TRUE);
1318		if (m_active_layers & 0x20) cischeat_draw_road(machine(),bitmap,cliprect,1,4,1,TRUE);
1319		if (m_active_layers & 0x08) cischeat_draw_sprites(machine(),bitmap,cliprect,2,2);
1320		if (m_active_layers & 0x10) cischeat_draw_road(machine(),bitmap,cliprect,0,0,0,TRUE);
1321		if (m_active_layers & 0x20) cischeat_draw_road(machine(),bitmap,cliprect,1,0,0,TRUE);
1322		if (m_active_layers & 0x08) cischeat_draw_sprites(machine(),bitmap,cliprect,1,0);
	1310	if (m_active_layers & 0x08) cischeat_draw_sprites(bitmap,cliprect,15,3);
	1311	if (m_active_layers & 0x10) cischeat_draw_road(bitmap,cliprect,0,4,1,TRUE);
	1312	if (m_active_layers & 0x20) cischeat_draw_road(bitmap,cliprect,1,4,1,TRUE);
	1313	if (m_active_layers & 0x08) cischeat_draw_sprites(bitmap,cliprect,2,2);
	1314	if (m_active_layers & 0x10) cischeat_draw_road(bitmap,cliprect,0,0,0,TRUE);
	1315	if (m_active_layers & 0x20) cischeat_draw_road(bitmap,cliprect,1,0,0,TRUE);
	1316	if (m_active_layers & 0x08) cischeat_draw_sprites(bitmap,cliprect,1,0);
1323	1317	cischeat_tmap_DRAW(2)
1324	1318
1325	1319	/* for the map screen */
1326		if (m_active_layers & 0x08) cischeat_draw_sprites(machine(),bitmap,cliprect,0+16,0+16);
	1320	if (m_active_layers & 0x08) cischeat_draw_sprites(bitmap,cliprect,0+16,0+16);
1327	1321
1328	1322
1329	1323	m_active_layers = active_layers1;
r20746	r20747
1363	1357	/*  1: clouds 5, grad 7, road 0     2: clouds 5, grad 7, road 0, tunnel roof 0 */
1364	1358
1365	1359	/* road 1!! 0!! */                  /* bitmap, road, min_priority, max_priority, transparency */
1366		if (m_active_layers & 0x20) f1gpstar_draw_road(machine(),bitmap,cliprect,1,6,7,TRUE);
1367		if (m_active_layers & 0x10) f1gpstar_draw_road(machine(),bitmap,cliprect,0,6,7,TRUE);
	1360	if (m_active_layers & 0x20) f1gpstar_draw_road(bitmap,cliprect,1,6,7,TRUE);
	1361	if (m_active_layers & 0x10) f1gpstar_draw_road(bitmap,cliprect,0,6,7,TRUE);
1368	1362
1369	1363	flag = 0;
1370	1364	cischeat_tmap_DRAW(0)
r20746	r20747
1372	1366	cischeat_tmap_DRAW(1)
1373	1367
1374	1368	/* road 1!! 0!! */                  /* bitmap, road, min_priority, max_priority, transparency */
1375		if (m_active_layers & 0x20) f1gpstar_draw_road(machine(),bitmap,cliprect,1,1,5,TRUE);
1376		if (m_active_layers & 0x10) f1gpstar_draw_road(machine(),bitmap,cliprect,0,1,5,TRUE);
	1369	if (m_active_layers & 0x20) f1gpstar_draw_road(bitmap,cliprect,1,1,5,TRUE);
	1370	if (m_active_layers & 0x10) f1gpstar_draw_road(bitmap,cliprect,0,1,5,TRUE);
1377	1371
1378		if (m_active_layers & 0x08) cischeat_draw_sprites(machine(),bitmap,cliprect,15,2);
	1372	if (m_active_layers & 0x08) cischeat_draw_sprites(bitmap,cliprect,15,2);
1379	1373
1380	1374	/* road 1!! 0!! */                  /* bitmap, road, min_priority, max_priority, transparency */
1381		if (m_active_layers & 0x20) f1gpstar_draw_road(machine(),bitmap,cliprect,1,0,0,TRUE);
1382		if (m_active_layers & 0x10) f1gpstar_draw_road(machine(),bitmap,cliprect,0,0,0,TRUE);
	1375	if (m_active_layers & 0x20) f1gpstar_draw_road(bitmap,cliprect,1,0,0,TRUE);
	1376	if (m_active_layers & 0x10) f1gpstar_draw_road(bitmap,cliprect,0,0,0,TRUE);
1383	1377
1384		if (m_active_layers & 0x08) cischeat_draw_sprites(machine(),bitmap,cliprect,1,1);
	1378	if (m_active_layers & 0x08) cischeat_draw_sprites(bitmap,cliprect,1,1);
1385	1379	cischeat_tmap_DRAW(2)
1386		if (m_active_layers & 0x08) cischeat_draw_sprites(machine(),bitmap,cliprect,0,0);
	1380	if (m_active_layers & 0x08) cischeat_draw_sprites(bitmap,cliprect,0,0);
1387	1381
1388	1382
1389	1383	m_active_layers = active_layers1;
r20746	r20747
1439	1433	flag = 0;
1440	1434	cischeat_tmap_DRAW(0)
1441	1435	// no layer 1
1442		if (m_active_layers & 0x08) cischeat_draw_sprites(machine(),bitmap,cliprect,0,15);
	1436	if (m_active_layers & 0x08) cischeat_draw_sprites(bitmap,cliprect,0,15);
1443	1437	cischeat_tmap_DRAW(2)
1444	1438
1445	1439	m_active_layers = active_layers1;

trunk/src/mame/video/cvs.c

r20746	r20747
65	65	}
66	66
67	67
68		static void set_pens( running_machine &machine )
	68	void cvs_state::set_pens(  )
69	69	{
70		cvs_state *state = machine.driver_data<cvs_state>();
71	70	int i;
72	71
73	72	for (i = 0; i < 0x10; i++)
74	73	{
75		int r = pal2bit(~state->m_palette_ram[i] >> 0);
76		int g = pal3bit(~state->m_palette_ram[i] >> 2);
77		int b = pal3bit(~state->m_palette_ram[i] >> 5);
	74	int r = pal2bit(~m_palette_ram[i] >> 0);
	75	int g = pal3bit(~m_palette_ram[i] >> 2);
	76	int b = pal3bit(~m_palette_ram[i] >> 5);
78	77
79		colortable_palette_set_color(machine.colortable, i, MAKE_RGB(r, g, b));
	78	colortable_palette_set_color(machine().colortable, i, MAKE_RGB(r, g, b));
80	79	}
81	80	}
82	81
r20746	r20747
122	121
123	122	VIDEO_START_MEMBER(cvs_state,cvs)
124	123	{
125		cvs_init_stars(machine());
	124	cvs_init_stars();
126	125
127	126	/* create helper bitmaps */
128	127	machine().primary_screen->register_screen_bitmap(m_background_bitmap);
r20746	r20747
142	141	offs_t offs;
143	142	int scroll[8];
144	143
145		set_pens(machine());
	144	set_pens();
146	145
147	146	/* draw the background */
148	147	for (offs = 0; offs < 0x0400; offs++)
r20746	r20747
262	261
263	262	/* stars circuit */
264	263	if (m_stars_on)
265		cvs_update_stars(machine(), bitmap, cliprect, BULLET_STAR_PEN, 0);
	264	cvs_update_stars(bitmap, cliprect, BULLET_STAR_PEN, 0);
266	265
267	266	return 0;
268	267	}
r20746	r20747
271	270
272	271	/* cvs stars hardware */
273	272
274		void cvs_scroll_stars( running_machine &machine )
	273	void cvs_state::cvs_scroll_stars(  )
275	274	{
276		cvs_state *state = machine.driver_data<cvs_state>();
277		state->m_stars_scroll++;
	275	m_stars_scroll++;
278	276	}
279	277
280		void cvs_init_stars( running_machine &machine )
	278	void cvs_state::cvs_init_stars(  )
281	279	{
282		cvs_state *state = machine.driver_data<cvs_state>();
283	280	int generator = 0;
284	281	int x, y;
285	282
286	283	/* precalculate the star background */
287	284
288		state->m_total_stars = 0;
	285	m_total_stars = 0;
289	286
290	287	for (y = 255; y >= 0; y--)
291	288	{
r20746	r20747
304	301	{
305	302	if(((~(generator >> 12)) & 0x01) && ((~(generator >> 13)) & 0x01))
306	303	{
307		if (state->m_total_stars < CVS_MAX_STARS)
	304	if (m_total_stars < CVS_MAX_STARS)
308	305	{
309		state->m_stars[state->m_total_stars].x = x;
310		state->m_stars[state->m_total_stars].y = y;
311		state->m_stars[state->m_total_stars].code = 1;
	306	m_stars[m_total_stars].x = x;
	307	m_stars[m_total_stars].y = y;
	308	m_stars[m_total_stars].code = 1;
312	309
313		state->m_total_stars++;
	310	m_total_stars++;
314	311	}
315	312	}
316	313	}
r20746	r20747
318	315	}
319	316	}
320	317
321		void cvs_update_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, const pen_t star_pen, bool update_always)
	318	void cvs_state::cvs_update_stars(bitmap_ind16 &bitmap, const rectangle &cliprect, const pen_t star_pen, bool update_always)
322	319	{
323		cvs_state *state = machine.driver_data<cvs_state>();
324		for (int offs = 0; offs < state->m_total_stars; offs++)
	320	for (int offs = 0; offs < m_total_stars; offs++)
325	321	{
326		UINT8 x = (state->m_stars[offs].x + state->m_stars_scroll) >> 1;
327		UINT8 y = state->m_stars[offs].y + ((state->m_stars_scroll + state->m_stars[offs].x) >> 9);
	322	UINT8 x = (m_stars[offs].x + m_stars_scroll) >> 1;
	323	UINT8 y = m_stars[offs].y + ((m_stars_scroll + m_stars[offs].x) >> 9);
328	324
329	325	if ((y & 1) ^ ((x >> 4) & 1))
330	326	{
331		if (state->flip_screen_x())
	327	if (flip_screen_x())
332	328	x = ~x;
333	329
334		if (state->flip_screen_y())
	330	if (flip_screen_y())
335	331	y = ~y;
336	332
337	333	if ((y >= cliprect.min_y) && (y <= cliprect.max_y) &&
338		(update_always || (colortable_entry_get_value(machine.colortable, bitmap.pix16(y, x)) == 0)))
	334	(update_always || (colortable_entry_get_value(machine().colortable, bitmap.pix16(y, x)) == 0)))
339	335	bitmap.pix16(y, x) = star_pen;
340	336	}
341	337	}

trunk/src/mame/video/centiped.c

r20746	r20747
63	63	*
64	64	*************************************/
65	65
66		static void init_penmask(running_machine &machine)
	66	void centiped_state::init_penmask()
67	67	{
68		centiped_state *state = machine.driver_data<centiped_state>();
69	68	int i;
70	69
71	70	for (i = 0; i < 64; i++)
r20746	r20747
74	73	if (((i >> 0) & 3) == 0) mask |= 2;
75	74	if (((i >> 2) & 3) == 0) mask |= 4;
76	75	if (((i >> 4) & 3) == 0) mask |= 8;
77		state->m_penmask[i] = mask;
	76	m_penmask[i] = mask;
78	77	}
79	78	}
80	79
81	80
82		static void init_common(running_machine &machine)
	81	void centiped_state::init_common()
83	82	{
84		centiped_state *state = machine.driver_data<centiped_state>();
85	83
86		state->save_item(NAME(state->m_flipscreen));
87		state->save_item(NAME(state->m_gfx_bank));
88		state->save_item(NAME(state->m_bullsdrt_sprites_bank));
	84	save_item(NAME(m_flipscreen));
	85	save_item(NAME(m_gfx_bank));
	86	save_item(NAME(m_bullsdrt_sprites_bank));
89	87
90		state->m_flipscreen = 0;
91		state->m_gfx_bank = 0;
92		state->m_bullsdrt_sprites_bank = 0;
	88	m_flipscreen = 0;
	89	m_gfx_bank = 0;
	90	m_bullsdrt_sprites_bank = 0;
93	91	}
94	92
95	93
96	94	VIDEO_START_MEMBER(centiped_state,centiped)
97	95	{
98		init_common(machine());
99		init_penmask(machine());
	96	init_common();
	97	init_penmask();
100	98
101	99	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(centiped_state::centiped_get_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
102	100	}
r20746	r20747
104	102
105	103	VIDEO_START_MEMBER(centiped_state,warlords)
106	104	{
107		init_common(machine());
	105	init_common();
108	106
109	107	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(centiped_state::warlords_get_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
110	108	}
r20746	r20747
112	110
113	111	VIDEO_START_MEMBER(centiped_state,milliped)
114	112	{
115		init_common(machine());
116		init_penmask(machine());
	113	init_common();
	114	init_penmask();
117	115
118	116	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(centiped_state::milliped_get_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
119	117	}
r20746	r20747
121	119
122	120	VIDEO_START_MEMBER(centiped_state,bullsdrt)
123	121	{
124		init_common(machine());
125		init_penmask(machine());
	122	init_common();
	123	init_penmask();
126	124
127	125	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(centiped_state::bullsdrt_get_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
128	126	}
r20746	r20747
339	337
340	338	***************************************************************************/
341	339
342		static void milliped_set_color(running_machine &machine, offs_t offset, UINT8 data)
	340	void centiped_state::milliped_set_color(offs_t offset, UINT8 data)
343	341	{
344	342	rgb_t color;
345	343	int bit0, bit1, bit2;
r20746	r20747
367	365
368	366	/* character colors, set directly */
369	367	if (offset < 0x10)
370		palette_set_color(machine, offset, color);
	368	palette_set_color(machine(), offset, color);
371	369
372	370	/* sprite colors - set all the applicable ones */
373	371	else
r20746	r20747
381	379	for (i = (base << 6); i < (base << 6) + 0x100; i += 4)
382	380	{
383	381	if (offset == ((i >> 2) & 0x03))
384		palette_set_color(machine, i + 0x10 + 1, color);
	382	palette_set_color(machine(), i + 0x10 + 1, color);
385	383
386	384	if (offset == ((i >> 4) & 0x03))
387		palette_set_color(machine, i + 0x10 + 2, color);
	385	palette_set_color(machine(), i + 0x10 + 2, color);
388	386
389	387	if (offset == ((i >> 6) & 0x03))
390		palette_set_color(machine, i + 0x10 + 3, color);
	388	palette_set_color(machine(), i + 0x10 + 3, color);
391	389	}
392	390	}
393	391	}
r20746	r20747
397	395	{
398	396	m_generic_paletteram_8[offset] = data;
399	397
400		milliped_set_color(machine(), offset, data);
	398	milliped_set_color(offset, data);
401	399	}
402	400
403	401
r20746	r20747
406	404	m_generic_paletteram_8[offset] = data;
407	405
408	406	/* the value passed in is a look-up index into the color PROM */
409		milliped_set_color(machine(), offset, ~machine().root_device().memregion("proms")->base()[~data & 0x0f]);
	407	milliped_set_color(offset, ~machine().root_device().memregion("proms")->base()[~data & 0x0f]);
410	408	}
411	409
412	410

trunk/src/mame/video/circus.c

r20746	r20747
39	39	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(circus_state::get_bg_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
40	40	}
41	41
42		static void draw_line( bitmap_ind16 &bitmap, const rectangle &cliprect, int x1, int y1, int x2, int y2, int dotted )
	42	void circus_state::draw_line( bitmap_ind16 &bitmap, const rectangle &cliprect, int x1, int y1, int x2, int y2, int dotted )
43	43	{
44	44	/* Draws horizontal and Vertical lines only! */
45	45	int count, skip;
r20746	r20747
58	58	bitmap.pix16(y1, count) = 1;
59	59	}
60	60
61		static void draw_sprite_collision( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	61	void circus_state::draw_sprite_collision( bitmap_ind16 &bitmap, const rectangle &cliprect )
62	62	{
63		circus_state *state = machine.driver_data<circus_state>();
64		gfx_element *sprite_gfx = machine.gfx[1];
65		const UINT8 *sprite_data = sprite_gfx->get_data(state->m_clown_z);
	63	gfx_element *sprite_gfx = machine().gfx[1];
	64	const UINT8 *sprite_data = sprite_gfx->get_data(m_clown_z);
66	65	int sx, sy, dx, dy;
67	66	int pixel, collision = 0;
68	67
69	68	// draw sprite and check collision on a pixel basis
70	69	for (sy = 0; sy < 16; sy++)
71	70	{
72		dy = state->m_clown_x + sy-1;
	71	dy = m_clown_x + sy-1;
73	72	if (dy>=0 && dy<bitmap.height())
74	73	{
75	74	for (sx = 0; sx < 16; sx++)
76	75	{
77		dx = state->m_clown_y + sx;
	76	dx = m_clown_y + sx;
78	77	if (dx>=0 && dx<bitmap.width())
79	78	{
80	79	pixel = sprite_data[sy * sprite_gfx->rowbytes() + sx];
81	80	if (pixel)
82	81	{
83	82	collision |= bitmap.pix16(dy, dx);
84		bitmap.pix16(dy, dx) = machine.pens[pixel];
	83	bitmap.pix16(dy, dx) = machine().pens[pixel];
85	84	}
86	85	}
87	86	}
r20746	r20747
89	88	}
90	89
91	90	if (collision)
92		state->m_maincpu->set_input_line(0, ASSERT_LINE);
	91	m_maincpu->set_input_line(0, ASSERT_LINE);
93	92	}
94	93
95		static void circus_draw_fg( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	94	void circus_state::circus_draw_fg( bitmap_ind16 &bitmap, const rectangle &cliprect )
96	95	{
97	96	/* The sync generator hardware is used to   */
98	97	/* draw the border and diving boards        */
r20746	r20747
111	110	UINT32 circus_state::screen_update_circus(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
112	111	{
113	112	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
114		circus_draw_fg(machine(), bitmap, cliprect);
115		draw_sprite_collision(machine(), bitmap, cliprect);
	113	circus_draw_fg(bitmap, cliprect);
	114	draw_sprite_collision(bitmap, cliprect);
116	115	return 0;
117	116	}
118	117
119		static void robotbwl_draw_box( bitmap_ind16 &bitmap, const rectangle &cliprect, int x, int y )
	118	void circus_state::robotbwl_draw_box( bitmap_ind16 &bitmap, const rectangle &cliprect, int x, int y )
120	119	{
121	120	/* Box */
122	121	int ex = x + 24;
r20746	r20747
134	133	draw_line(bitmap, cliprect, x + 16, y, x + 16, ey, 0);
135	134	}
136	135
137		static void robotbwl_draw_scoreboard( bitmap_ind16 &bitmap, const rectangle &cliprect )
	136	void circus_state::robotbwl_draw_scoreboard( bitmap_ind16 &bitmap, const rectangle &cliprect )
138	137	{
139	138	int offs;
140	139
r20746	r20747
159	158	draw_line(bitmap, cliprect, 39 + 152, 137, 47 + 152, 137, 0);
160	159	}
161	160
162		static void robotbwl_draw_bowling_alley( bitmap_ind16 &bitmap, const rectangle &cliprect )
	161	void circus_state::robotbwl_draw_bowling_alley( bitmap_ind16 &bitmap, const rectangle &cliprect )
163	162	{
164	163	draw_line(bitmap, cliprect, 103, 17, 103, 205, 0);
165	164	draw_line(bitmap, cliprect, 111, 17, 111, 203, 1);
r20746	r20747
167	166	draw_line(bitmap, cliprect, 144, 17, 144, 203, 1);
168	167	}
169	168
170		static void robotbwl_draw_ball( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	169	void circus_state::robotbwl_draw_ball( bitmap_ind16 &bitmap, const rectangle &cliprect )
171	170	{
172		circus_state *state = machine.driver_data<circus_state>();
173	171	drawgfx_transpen(bitmap,/* Y is horizontal position */
174		cliprect,machine.gfx[1],
175		state->m_clown_z,
	172	cliprect,machine().gfx[1],
	173	m_clown_z,
176	174	0,
177	175	0,0,
178		state->m_clown_y + 8, state->m_clown_x + 8, 0);
	176	m_clown_y + 8, m_clown_x + 8, 0);
179	177	}
180	178
181	179	UINT32 circus_state::screen_update_robotbwl(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
r20746	r20747
183	181	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
184	182	robotbwl_draw_scoreboard(bitmap, cliprect);
185	183	robotbwl_draw_bowling_alley(bitmap, cliprect);
186		robotbwl_draw_ball(machine(), bitmap, cliprect);
	184	robotbwl_draw_ball(bitmap, cliprect);
187	185	return 0;
188	186	}
189	187
190		static void crash_draw_car( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	188	void circus_state::crash_draw_car( bitmap_ind16 &bitmap, const rectangle &cliprect )
191	189	{
192		circus_state *state = machine.driver_data<circus_state>();
193	190	drawgfx_transpen(bitmap,/* Y is horizontal position */
194		cliprect,machine.gfx[1],
195		state->m_clown_z,
	191	cliprect,machine().gfx[1],
	192	m_clown_z,
196	193	0,
197	194	0,0,
198		state->m_clown_y, state->m_clown_x - 1, 0);
	195	m_clown_y, m_clown_x - 1, 0);
199	196	}
200	197
201	198	UINT32 circus_state::screen_update_crash(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
202	199	{
203	200	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
204		crash_draw_car(machine(), bitmap, cliprect);
	201	crash_draw_car(bitmap, cliprect);
205	202	return 0;
206	203	}
207	204
208	205	UINT32 circus_state::screen_update_ripcord(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
209	206	{
210	207	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
211		draw_sprite_collision(machine(), bitmap, cliprect);
	208	draw_sprite_collision(bitmap, cliprect);
212	209	return 0;
213	210	}

trunk/src/mame/video/commando.c

r20746	r20747
87	87	m_fg_tilemap->set_transparent_pen(3);
88	88	}
89	89
90		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	90	void commando_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
91	91	{
92		commando_state *state = machine.driver_data<commando_state>();
93		UINT8 *buffered_spriteram = state->m_spriteram->buffer();
	92	UINT8 *buffered_spriteram = m_spriteram->buffer();
94	93	int offs;
95	94
96		for (offs = state->m_spriteram->bytes() - 4; offs >= 0; offs -= 4)
	95	for (offs = m_spriteram->bytes() - 4; offs >= 0; offs -= 4)
97	96	{
98	97	// bit 1 of attr is not used
99	98	int attr = buffered_spriteram[offs + 1];
r20746	r20747
105	104	int sx = buffered_spriteram[offs + 3] - ((attr & 0x01) << 8);
106	105	int sy = buffered_spriteram[offs + 2];
107	106
108		if (state->flip_screen())
	107	if (flip_screen())
109	108	{
110	109	sx = 240 - sx;
111	110	sy = 240 - sy;
r20746	r20747
114	113	}
115	114
116	115	if (bank < 3)
117		drawgfx_transpen(bitmap, cliprect, machine.gfx[2], code, color, flipx, flipy, sx, sy, 15);
	116	drawgfx_transpen(bitmap, cliprect, machine().gfx[2], code, color, flipx, flipy, sx, sy, 15);
118	117	}
119	118	}
120	119
121	120	UINT32 commando_state::screen_update_commando(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
122	121	{
123	122	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
124		draw_sprites(machine(), bitmap, cliprect);
	123	draw_sprites(bitmap, cliprect);
125	124	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
126	125	return 0;
127	126	}

trunk/src/mame/video/cloak.c

r20746	r20747
44	44	}
45	45
46	46
47		static void set_pens(running_machine &machine)
	47	void cloak_state::set_pens()
48	48	{
49		cloak_state *state = machine.driver_data<cloak_state>();
50		UINT16 *palette_ram = state->m_palette_ram;
	49	UINT16 *palette_ram = m_palette_ram;
51	50	static const int resistances[3] = { 10000, 4700, 2200 };
52	51	double weights[3];
53	52	int i;
r20746	r20747
81	80	bit2 = (~palette_ram[i] >> 2) & 0x01;
82	81	b = combine_3_weights(weights, bit0, bit1, bit2);
83	82
84		palette_set_color(machine, i, MAKE_RGB(r, g, b));
	83	palette_set_color(machine(), i, MAKE_RGB(r, g, b));
85	84	}
86	85	}
87	86
r20746	r20747
178	177	machine().save().register_postload(save_prepost_delegate(FUNC(cloak_state::set_current_bitmap_videoram_pointer), this));
179	178	}
180	179
181		static void draw_bitmap(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	180	void cloak_state::draw_bitmap(bitmap_ind16 &bitmap, const rectangle &cliprect)
182	181	{
183		cloak_state *state = machine.driver_data<cloak_state>();
184	182	int x, y;
185	183
186	184	for (y = cliprect.min_y; y <= cliprect.max_y; y++)
187	185	for (x = cliprect.min_x; x <= cliprect.max_x; x++)
188	186	{
189		pen_t pen = state->m_current_bitmap_videoram_displayed[(y << 8) | x] & 0x07;
	187	pen_t pen = m_current_bitmap_videoram_displayed[(y << 8) | x] & 0x07;
190	188
191	189	if (pen)
192	190	bitmap.pix16(y, (x - 6) & 0xff) = 0x10 | ((x & 0x80) >> 4) | pen;
193	191	}
194	192	}
195	193
196		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	194	void cloak_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
197	195	{
198		cloak_state *state = machine.driver_data<cloak_state>();
199		UINT8 *spriteram = state->m_spriteram;
	196	UINT8 *spriteram = m_spriteram;
200	197	int offs;
201	198
202	199	for (offs = (0x100 / 4) - 1; offs >= 0; offs--)
r20746	r20747
207	204	int sx = spriteram[offs + 192];
208	205	int sy = 240 - spriteram[offs];
209	206
210		if (state->flip_screen())
	207	if (flip_screen())
211	208	{
212	209	sx -= 9;
213	210	sy = 240 - sy;
r20746	r20747
215	212	flipy = !flipy;
216	213	}
217	214
218		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code, 0, flipx, flipy,   sx, sy, 0);
	215	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code, 0, flipx, flipy,   sx, sy, 0);
219	216	}
220	217	}
221	218
222	219	UINT32 cloak_state::screen_update_cloak(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
223	220	{
224		set_pens(machine());
	221	set_pens();
225	222	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
226		draw_bitmap(machine(), bitmap, cliprect);
227		draw_sprites(machine(), bitmap, cliprect);
	223	draw_bitmap(bitmap, cliprect);
	224	draw_sprites(bitmap, cliprect);
228	225	return 0;
229	226	}

trunk/src/mame/video/cloud9.c

r20746	r20747
105	105	*
106	106	*************************************/
107	107
108		INLINE void cloud9_write_vram( running_machine &machine, UINT16 addr, UINT8 data, UINT8 bitmd, UINT8 pixba )
	108	inline void cloud9_state::cloud9_write_vram( UINT16 addr, UINT8 data, UINT8 bitmd, UINT8 pixba )
109	109	{
110		cloud9_state *state = machine.driver_data<cloud9_state>();
111		UINT8 *dest = &state->m_videoram[0x0000 | (addr & 0x3fff)];
112		UINT8 *dest2 = &state->m_videoram[0x4000 | (addr & 0x3fff)];
	110	UINT8 *dest = &m_videoram[0x0000 | (addr & 0x3fff)];
	111	UINT8 *dest2 = &m_videoram[0x4000 | (addr & 0x3fff)];
113	112	UINT8 promaddr = 0;
114	113	UINT8 wpbits;
115	114
r20746	r20747
126	125	Bit 0 = PIXA
127	126	*/
128	127	promaddr |= bitmd << 7;
129		promaddr |= state->m_video_control[4] << 6;
130		promaddr |= state->m_video_control[6] << 5;
	128	promaddr |= m_video_control[4] << 6;
	129	promaddr |= m_video_control[6] << 5;
131	130	promaddr |= ((addr & 0xf000) != 0x4000) << 4;
132	131	promaddr |= ((addr & 0x3800) == 0x0000) << 3;
133	132	promaddr |= ((addr & 0x0600) == 0x0600) << 2;
134	133	promaddr |= (pixba << 0);
135	134
136	135	/* look up the PROM result */
137		wpbits = state->m_wpprom[promaddr];
	136	wpbits = m_wpprom[promaddr];
138	137
139	138	/* write to the appropriate parts of VRAM depending on the result */
140	139	if (!(wpbits & 1))
r20746	r20747
155	154	*
156	155	*************************************/
157	156
158		INLINE void bitmode_autoinc( running_machine &machine )
	157	inline void cloud9_state::bitmode_autoinc(  )
159	158	{
160		cloud9_state *state = machine.driver_data<cloud9_state>();
161	159
162	160	/* auto increment in the x-direction if it's enabled */
163		if (!state->m_video_control[0]) /* /AX */
164		state->m_bitmode_addr[0]++;
	161	if (!m_video_control[0]) /* /AX */
	162	m_bitmode_addr[0]++;
165	163
166	164	/* auto increment in the y-direction if it's enabled */
167		if (!state->m_video_control[1]) /* /AY */
168		state->m_bitmode_addr[1]++;
	165	if (!m_video_control[1]) /* /AY */
	166	m_bitmode_addr[1]++;
169	167	}
170	168
171	169
r20746	r20747
179	177	WRITE8_MEMBER(cloud9_state::cloud9_videoram_w)
180	178	{
181	179	/* direct writes to VRAM go through the write protect PROM as well */
182		cloud9_write_vram(machine(), offset, data, 0, 0);
	180	cloud9_write_vram(offset, data, 0, 0);
183	181	}
184	182
185	183
r20746	r20747
199	197	UINT8 result = m_videoram[((~m_bitmode_addr[0] & 2) << 13) | addr] << ((m_bitmode_addr[0] & 1) * 4);
200	198
201	199	/* autoincrement because /BITMD was selected */
202		bitmode_autoinc(machine());
	200	bitmode_autoinc();
203	201
204	202	/* the upper 4 bits of the data lines are not driven so make them all 1's */
205	203	return (result >> 4) | 0xf0;
r20746	r20747
215	213	data = (data & 0x0f) | (data << 4);
216	214
217	215	/* write through the generic VRAM routine, passing the low 2 X bits as PIXB/PIXA */
218		cloud9_write_vram(machine(), addr, data, 1, m_bitmode_addr[0] & 3);
	216	cloud9_write_vram(addr, data, 1, m_bitmode_addr[0] & 3);
219	217
220	218	/* autoincrement because /BITMD was selected */
221		bitmode_autoinc(machine());
	219	bitmode_autoinc();
222	220	}
223	221
224	222
225	223	WRITE8_MEMBER(cloud9_state::cloud9_bitmode_addr_w)
226	224	{
227	225	/* write through to video RAM and also to the addressing latches */
228		cloud9_write_vram(machine(), offset, data, 0, 0);
	226	cloud9_write_vram(offset, data, 0, 0);
229	227	m_bitmode_addr[offset] = data;
230	228	}
231	229

trunk/src/mame/video/cheekyms.c

r20746	r20747
103	103	}
104	104
105	105
106		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx, int flip )
	106	void cheekyms_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx, int flip )
107	107	{
108		cheekyms_state *state = machine.driver_data<cheekyms_state>();
109	108	offs_t offs;
110	109
111	110	for (offs = 0; offs < 0x20; offs += 4)
112	111	{
113	112	int x, y, code, color;
114	113
115		if ((state->m_spriteram[offs + 3] & 0x08) == 0x00) continue;
	114	if ((m_spriteram[offs + 3] & 0x08) == 0x00) continue;
116	115
117		x  = 256 - state->m_spriteram[offs + 2];
118		y  = state->m_spriteram[offs + 1];
119		code =  (~state->m_spriteram[offs + 0] & 0x0f) << 1;
120		color = (~state->m_spriteram[offs + 3] & 0x07);
	116	x  = 256 - m_spriteram[offs + 2];
	117	y  = m_spriteram[offs + 1];
	118	code =  (~m_spriteram[offs + 0] & 0x0f) << 1;
	119	color = (~m_spriteram[offs + 3] & 0x07);
121	120
122		if (state->m_spriteram[offs + 0] & 0x80)
	121	if (m_spriteram[offs + 0] & 0x80)
123	122	{
124	123	if (!flip)
125	124	code++;
r20746	r20747
128	127	}
129	128	else
130	129	{
131		if (state->m_spriteram[offs + 0] & 0x02)
	130	if (m_spriteram[offs + 0] & 0x02)
132	131	{
133	132	drawgfx_transpen(bitmap, cliprect, gfx, code | 0x20, color, 0, 0,        x, y, 0);
134	133	drawgfx_transpen(bitmap, cliprect, gfx, code | 0x21, color, 0, 0, 0x10 + x, y, 0);
r20746	r20747
156	155	m_bitmap_buffer->fill(0, cliprect);
157	156
158	157	/* sprites go under the playfield */
159		draw_sprites(machine(), bitmap, cliprect, machine().gfx[1], flip);
	158	draw_sprites(bitmap, cliprect, machine().gfx[1], flip);
160	159
161	160	/* draw the tilemap to a temp bitmap */
162	161	m_cm_tilemap->draw(*m_bitmap_buffer, cliprect, 0, 0);

trunk/src/mame/drivers/cischeat.c

r20746	r20747
1781	1781
1782	1782	We need to untangle it
1783	1783	*/
1784		static void cischeat_untangle_sprites(running_machine &machine, const char *region)
	1784	void cischeat_state::cischeat_untangle_sprites(const char *region)
1785	1785	{
1786		UINT8       *src = machine.root_device().memregion(region)->base();
1787		const UINT8 *end = src + machine.root_device().memregion(region)->bytes();
	1786	UINT8       *src = machine().root_device().memregion(region)->base();
	1787	const UINT8 *end = src + machine().root_device().memregion(region)->bytes();
1788	1788
1789	1789	while (src < end)
1790	1790	{
r20746	r20747
1936	1936
1937	1937	DRIVER_INIT_MEMBER(cischeat_state,bigrun)
1938	1938	{
1939		cischeat_untangle_sprites(machine(), "gfx4");   // Untangle sprites
	1939	cischeat_untangle_sprites("gfx4");   // Untangle sprites
1940	1940	phantasm_rom_decode(machine(), "soundcpu");                 // Decrypt sound cpu code
1941	1941	}
1942	1942
r20746	r20747
2055	2055
2056	2056	DRIVER_INIT_MEMBER(cischeat_state,cischeat)
2057	2057	{
2058		cischeat_untangle_sprites(machine(), "gfx4");   // Untangle sprites
	2058	cischeat_untangle_sprites("gfx4");   // Untangle sprites
2059	2059	astyanax_rom_decode(machine(), "soundcpu");                 // Decrypt sound cpu code
2060	2060	}
2061	2061
r20746	r20747
2269	2269
2270	2270	DRIVER_INIT_MEMBER(cischeat_state,f1gpstar)
2271	2271	{
2272		cischeat_untangle_sprites(machine(), "gfx4");
	2272	cischeat_untangle_sprites("gfx4");
2273	2273	}
2274	2274
2275	2275

trunk/src/mame/drivers/centiped.c

r20746	r20747
512	512	* to prevent the counter from wrapping around between reads.
513	513	*/
514	514
515		INLINE int read_trackball(running_machine &machine, int idx, int switch_port)
	515	inline int centiped_state::read_trackball(int idx, int switch_port)
516	516	{
517		centiped_state *state = machine.driver_data<centiped_state>();
518	517	UINT8 newpos;
519	518	static const char *const portnames[] = { "IN0", "IN1", "IN2" };
520	519	static const char *const tracknames[] = { "TRACK0_X", "TRACK0_Y", "TRACK1_X", "TRACK1_Y" };
521	520
522	521	/* adjust idx if we're cocktail flipped */
523		if (state->m_flipscreen)
	522	if (m_flipscreen)
524	523	idx += 2;
525	524
526	525	/* if we're to read the dipswitches behind the trackball data, do it now */
527		if (state->m_dsw_select)
528		return (machine.root_device().ioport(portnames[switch_port])->read() & 0x7f) | state->m_sign[idx];
	526	if (m_dsw_select)
	527	return (machine().root_device().ioport(portnames[switch_port])->read() & 0x7f) | m_sign[idx];
529	528
530	529	/* get the new position and adjust the result */
531		newpos = machine.root_device().ioport(tracknames[idx])->read();
532		if (newpos != state->m_oldpos[idx])
	530	newpos = machine().root_device().ioport(tracknames[idx])->read();
	531	if (newpos != m_oldpos[idx])
533	532	{
534		state->m_sign[idx] = (newpos - state->m_oldpos[idx]) & 0x80;
535		state->m_oldpos[idx] = newpos;
	533	m_sign[idx] = (newpos - m_oldpos[idx]) & 0x80;
	534	m_oldpos[idx] = newpos;
536	535	}
537	536
538	537	/* blend with the bits from the switch port */
539		return (machine.root_device().ioport(portnames[switch_port])->read() & 0x70) | (state->m_oldpos[idx] & 0x0f) | state->m_sign[idx];
	538	return (machine().root_device().ioport(portnames[switch_port])->read() & 0x70) | (m_oldpos[idx] & 0x0f) | m_sign[idx];
540	539	}
541	540
542	541
543	542	READ8_MEMBER(centiped_state::centiped_IN0_r)
544	543	{
545		return read_trackball(machine(), 0, 0);
	544	return read_trackball(0, 0);
546	545	}
547	546
548	547
549	548	READ8_MEMBER(centiped_state::centiped_IN2_r)
550	549	{
551		return read_trackball(machine(), 1, 2);
	550	return read_trackball(1, 2);
552	551	}
553	552
554	553
555	554	READ8_MEMBER(centiped_state::milliped_IN1_r)
556	555	{
557		return read_trackball(machine(), 1, 1);
	556	return read_trackball(1, 1);
558	557	}
559	558
560	559	READ8_MEMBER(centiped_state::milliped_IN2_r)

trunk/src/mame/drivers/cvs.c

r20746	r20747
221	221	device.execute().set_input_line_vector(0, 0x03);
222	222	generic_pulse_irq_line(device.execute(), 0, 1);
223	223
224		cvs_scroll_stars(machine());
	224	cvs_scroll_stars();
225	225	}
226	226
227	227
r20746	r20747
296	296	}
297	297
298	298
299		static void start_393hz_timer(running_machine &machine)
	299	void cvs_state::start_393hz_timer()
300	300	{
301		cvs_state *state = machine.driver_data<cvs_state>();
302		state->m_cvs_393hz_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(cvs_state::cvs_393hz_timer_cb),state));
303		state->m_cvs_393hz_timer->adjust(attotime::from_hz(30*393), 0, attotime::from_hz(30*393));
	301	m_cvs_393hz_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(cvs_state::cvs_393hz_timer_cb),this));
	302	m_cvs_393hz_timer->adjust(attotime::from_hz(30*393), 0, attotime::from_hz(30*393));
304	303	}
305	304
306	305
r20746	r20747
980	979	if (machine().gfx[1] != NULL)
981	980	machine().gfx[1]->set_source(m_character_ram);
982	981
983		start_393hz_timer(machine());
	982	start_393hz_timer();
984	983
985	984	/* set devices */
986	985	m_maincpu = machine().device<cpu_device>("maincpu");

trunk/src/mame/drivers/cps3.c

r20746	r20747
408	408	#define CPS3_TRANSPARENCY_PEN_INDEX 2
409	409	#define CPS3_TRANSPARENCY_PEN_INDEX_BLEND 3
410	410
411		static void copy_from_nvram(running_machine &machine);
412
413		INLINE void cps3_drawgfxzoom(bitmap_rgb32 &dest_bmp,const rectangle &clip,gfx_element *gfx,
	411	inline void cps3_state::cps3_drawgfxzoom(bitmap_rgb32 &dest_bmp,const rectangle &clip,gfx_element *gfx,
414	412	unsigned int code,unsigned int color,int flipx,int flipy,int sx,int sy,
415	413	int transparency,int transparent_color,
416	414	int scalex, int scaley,bitmap_ind8 *pri_buffer,UINT32 pri_mask)
417	415	{
418		cps3_state *state = gfx->machine().driver_data<cps3_state>();
419	416	rectangle myclip;
420	417
421	418	//  UINT8 al;
r20746	r20747
449	446	{
450	447	//          const pen_t *pal = &gfx->colortable[gfx->granularity() * (color % gfx->colors())];
451	448	UINT32 palbase = (gfx->granularity() * color) & 0x1ffff;
452		const pen_t *pal = &state->m_mame_colours[palbase];
	449	const pen_t *pal = &m_mame_colours[palbase];
453	450	const UINT8 *source_base = gfx->get_data(code % gfx->elements());
454	451
455	452	int sprite_screen_height = (scaley*gfx->height()+0x8000)>>16;
r20746	r20747
625	622	/* Encryption */
626	623
627	624
628		static UINT16 rotate_left(UINT16 value, int n)
	625	UINT16 cps3_state::rotate_left(UINT16 value, int n)
629	626	{
630	627	int aux = value>>(16-n);
631	628	return ((value<<n)|aux)%0x10000;
632	629	}
633	630
634		static UINT16 rotxor(UINT16 val, UINT16 xorval)
	631	UINT16 cps3_state::rotxor(UINT16 val, UINT16 xorval)
635	632	{
636	633	UINT16 res;
637	634
r20746	r20747
642	639	return res;
643	640	}
644	641
645		static UINT32 cps3_mask(UINT32 address, UINT32 key1, UINT32 key2)
	642	UINT32 cps3_state::cps3_mask(UINT32 address, UINT32 key1, UINT32 key2)
646	643	{
647	644	UINT16 val;
648	645
r20746	r20747
661	658	return val | (val << 16);
662	659	}
663	660
664		static void cps3_decrypt_bios(running_machine &machine)
	661	void cps3_state::cps3_decrypt_bios()
665	662	{
666		cps3_state *state = machine.driver_data<cps3_state>();
667	663	int i;
668		UINT32 *coderegion = (UINT32*)state->memregion("user1")->base();
	664	UINT32 *coderegion = (UINT32*)memregion("user1")->base();
669	665
670		state->m_decrypted_bios = (UINT32*)state->memregion("user1")->base();
	666	m_decrypted_bios = (UINT32*)memregion("user1")->base();
671	667
672	668	for (i=0;i<0x80000;i+=4)
673	669	{
674	670	UINT32 dword = coderegion[i/4];
675		UINT32 xormask = cps3_mask(i, state->m_key1, state->m_key2);
676		state->m_decrypted_bios[i/4] = dword ^ xormask;
	671	UINT32 xormask = cps3_mask(i, m_key1, m_key2);
	672	m_decrypted_bios[i/4] = dword ^ xormask;
677	673	}
678	674	#if 0
679	675	/* Dump to file */
680	676	{
681	677	FILE *fp;
682		const char *gamename = machine.system().name;
	678	const char *gamename = machine().system().name;
683	679	char filename[256];
684	680	sprintf(filename, "%s_bios.dump", gamename);
685	681
686	682	fp=fopen(filename, "w+b");
687	683	if (fp)
688	684	{
689		fwrite(state->m_decrypted_bios, 0x080000, 1, fp);
	685	fwrite(m_decrypted_bios, 0x080000, 1, fp);
690	686	fclose(fp);
691	687	}
692	688	}
r20746	r20747
694	690	}
695	691
696	692
697		static void init_common(running_machine &machine, UINT32 key1, UINT32 key2, int altEncryption)
	693	void cps3_state::init_common(UINT32 key1, UINT32 key2, int altEncryption)
698	694	{
699		cps3_state *state = machine.driver_data<cps3_state>();
700	695
701		state->m_key1 = key1;
702		state->m_key2 = key2;
703		state->m_altEncryption = altEncryption;
	696	m_key1 = key1;
	697	m_key2 = key2;
	698	m_altEncryption = altEncryption;
704	699
705	700	// cache pointers to regions
706		state->m_user4region = state->memregion("user4")->base();
707		state->m_user5region = state->memregion("user5")->base();
	701	m_user4region = memregion("user4")->base();
	702	m_user5region = memregion("user5")->base();
708	703
709		if (!state->m_user4region) state->m_user4region = auto_alloc_array(machine, UINT8, USER4REGION_LENGTH);
710		if (!state->m_user5region) state->m_user5region = auto_alloc_array(machine, UINT8, USER5REGION_LENGTH);
	704	if (!m_user4region) m_user4region = auto_alloc_array(machine(), UINT8, USER4REGION_LENGTH);
	705	if (!m_user5region) m_user5region = auto_alloc_array(machine(), UINT8, USER5REGION_LENGTH);
711	706
712	707	// set strict verify
713		sh2drc_set_options(machine.device("maincpu"), SH2DRC_STRICT_VERIFY);
	708	sh2drc_set_options(machine().device("maincpu"), SH2DRC_STRICT_VERIFY);
714	709
715		cps3_decrypt_bios(machine);
716		state->m_decrypted_gamerom = auto_alloc_array(machine, UINT32, 0x1000000/4);
	710	cps3_decrypt_bios();
	711	m_decrypted_gamerom = auto_alloc_array(machine(), UINT32, 0x1000000/4);
717	712
718	713	/* just some NOPs for the game to execute if it crashes and starts executing unmapped addresses
719	714	- this prevents MAME from crashing */
720		state->m_nops = auto_alloc(machine, UINT32);
721		state->m_nops[0] = 0x00090009;
	715	m_nops = auto_alloc(machine(), UINT32);
	716	m_nops[0] = 0x00090009;
722	717
723	718
724		state->m_0xc0000000_ram_decrypted = auto_alloc_array(machine, UINT32, 0x400/4);
	719	m_0xc0000000_ram_decrypted = auto_alloc_array(machine(), UINT32, 0x400/4);
725	720
726		address_space &main = machine.device<sh2_device>("maincpu")->space(AS_PROGRAM);
727		main.set_direct_update_handler(direct_update_delegate(FUNC(cps3_state::cps3_direct_handler), state));
	721	address_space &main = machine().device<sh2_device>("maincpu")->space(AS_PROGRAM);
	722	main.set_direct_update_handler(direct_update_delegate(FUNC(cps3_state::cps3_direct_handler), this));
728	723
729	724	// flash roms
730	725	astring tempstr;
731	726	for (int simmnum = 0; simmnum < 7; simmnum++)
732	727	for (int chipnum = 0; chipnum < 8; chipnum++)
733		state->m_simm[simmnum][chipnum] = machine.device<fujitsu_29f016a_device>(tempstr.format("simm%d.%d", simmnum + 1, chipnum));
	728	m_simm[simmnum][chipnum] = machine().device<fujitsu_29f016a_device>(tempstr.format("simm%d.%d", simmnum + 1, chipnum));
734	729
735		state->m_eeprom = auto_alloc_array(machine, UINT32, 0x400/4);
736		machine.device<nvram_device>("eeprom")->set_base(state->m_eeprom, 0x400);
	730	m_eeprom = auto_alloc_array(machine(), UINT32, 0x400/4);
	731	machine().device<nvram_device>("eeprom")->set_base(m_eeprom, 0x400);
737	732	}
738	733
739		DRIVER_INIT_MEMBER(cps3_state,redearth)  { init_common(machine(), 0x9e300ab1, 0xa175b82c, 0); }
740		DRIVER_INIT_MEMBER(cps3_state,sfiii)     { init_common(machine(), 0xb5fe053e, 0xfc03925a, 0); }
741		DRIVER_INIT_MEMBER(cps3_state,sfiii2)    { init_common(machine(), 0x00000000, 0x00000000, 1); }
742		DRIVER_INIT_MEMBER(cps3_state,jojo)      { init_common(machine(), 0x02203ee3, 0x01301972, 0); }
743		DRIVER_INIT_MEMBER(cps3_state,sfiii3)    { init_common(machine(), 0xa55432b4, 0x0c129981, 0); }
744		DRIVER_INIT_MEMBER(cps3_state,jojoba)    { init_common(machine(), 0x23323ee3, 0x03021972, 0); }
	734	DRIVER_INIT_MEMBER(cps3_state,redearth)  { init_common(0x9e300ab1, 0xa175b82c, 0); }
	735	DRIVER_INIT_MEMBER(cps3_state,sfiii)     { init_common(0xb5fe053e, 0xfc03925a, 0); }
	736	DRIVER_INIT_MEMBER(cps3_state,sfiii2)    { init_common(0x00000000, 0x00000000, 1); }
	737	DRIVER_INIT_MEMBER(cps3_state,jojo)      { init_common(0x02203ee3, 0x01301972, 0); }
	738	DRIVER_INIT_MEMBER(cps3_state,sfiii3)    { init_common(0xa55432b4, 0x0c129981, 0); }
	739	DRIVER_INIT_MEMBER(cps3_state,jojoba)    { init_common(0x23323ee3, 0x03021972, 0); }
745	740
746	741
747	742
r20746	r20747
775	770	};
776	771
777	772
778		static void cps3_set_mame_colours(running_machine &machine, int colournum, UINT16 data, UINT32 fadeval)
	773	void cps3_state::cps3_set_mame_colours(int colournum, UINT16 data, UINT32 fadeval)
779	774	{
780		cps3_state *state = machine.driver_data<cps3_state>();
781	775	int r,g,b;
782		UINT16* dst = (UINT16*)state->m_colourram.target();
	776	UINT16* dst = (UINT16*)m_colourram.target();
783	777
784	778
785	779	r = (data >> 0) & 0x1f;
r20746	r20747
809	803
810	804	dst[colournum] = data;
811	805
812		state->m_mame_colours[colournum] = (r << (16+3)) | (g << (8+3)) | (b << (0+3));
	806	m_mame_colours[colournum] = (r << (16+3)) | (g << (8+3)) | (b << (0+3));
813	807
814		if (colournum<0x10000) palette_set_color(machine,colournum,state->m_mame_colours[colournum]/* MAKE_RGB(r<<3,g<<3,b<<3)*/);//state->m_mame_colours[colournum]);
	808	if (colournum<0x10000) palette_set_color(machine(),colournum,m_mame_colours[colournum]/* MAKE_RGB(r<<3,g<<3,b<<3)*/);//m_mame_colours[colournum]);
815	809	}
816	810
817	811
r20746	r20747
853	847
854	848	// the 0x400 bit in the tilemap regs is "draw it upside-down"  (bios tilemap during flashing, otherwise capcom logo is flipped)
855	849
856		static void cps3_draw_tilemapsprite_line(running_machine &machine, int tmnum, int drawline, bitmap_rgb32 &bitmap, const rectangle &cliprect )
	850	void cps3_state::cps3_draw_tilemapsprite_line(int tmnum, int drawline, bitmap_rgb32 &bitmap, const rectangle &cliprect )
857	851	{
858		cps3_state *state = machine.driver_data<cps3_state>();
859		UINT32* tmapregs[4] = { state->m_tilemap20_regs_base, state->m_tilemap30_regs_base, state->m_tilemap40_regs_base, state->m_tilemap50_regs_base };
	852	UINT32* tmapregs[4] = { m_tilemap20_regs_base, m_tilemap30_regs_base, m_tilemap40_regs_base, m_tilemap50_regs_base };
860	853	UINT32* regs;
861	854	int line;
862	855	int scrolly;
r20746	r20747
897	890	//  printf("linebase %08x\n", linebase);
898	891
899	892	scrollx =  (regs[0]&0xffff0000)>>16;
900		scrollx+= (state->m_spriteram[linebase+((line+16-4)&0x3ff)]>>16)&0x3ff;
	893	scrollx+= (m_spriteram[linebase+((line+16-4)&0x3ff)]>>16)&0x3ff;
901	894
902	895	}
903	896
r20746	r20747
917	910	int bpp;
918	911	int xflip,yflip;
919	912
920		dat = state->m_spriteram[mapbase+((tileline&63)*64)+((x+scrollx/16)&63)];
	913	dat = m_spriteram[mapbase+((tileline&63)*64)+((x+scrollx/16)&63)];
921	914	tileno = (dat & 0xffff0000)>>17;
922	915	colour = (dat & 0x000001ff)>>0;
923	916	bpp = (dat & 0x0000200)>>9;
924	917	yflip  = (dat & 0x00000800)>>11;
925	918	xflip  = (dat & 0x00001000)>>12;
926	919
927		if (!bpp) machine.gfx[1]->set_granularity(256);
928		else machine.gfx[1]->set_granularity(64);
	920	if (!bpp) machine().gfx[1]->set_granularity(256);
	921	else machine().gfx[1]->set_granularity(64);
929	922
930		cps3_drawgfxzoom(bitmap,clip,machine.gfx[1],tileno,colour,xflip,yflip,(x*16)-scrollx%16,drawline-tilesubline,CPS3_TRANSPARENCY_PEN_INDEX,0, 0x10000, 0x10000, NULL, 0);
	923	cps3_drawgfxzoom(bitmap,clip,machine().gfx[1],tileno,colour,xflip,yflip,(x*16)-scrollx%16,drawline-tilesubline,CPS3_TRANSPARENCY_PEN_INDEX,0, 0x10000, 0x10000, NULL, 0);
931	924	}
932	925	}
933	926	}
r20746	r20747
1080	1073	{
1081	1074	for (uu=0;uu<1023;uu++)
1082	1075	{
1083		cps3_draw_tilemapsprite_line(machine(), tilemapnum, uu, m_renderbuffer_bitmap, m_renderbuffer_clip );
	1076	cps3_draw_tilemapsprite_line(tilemapnum, uu, m_renderbuffer_bitmap, m_renderbuffer_clip );
1084	1077	}
1085	1078	}
1086	1079	bg_drawn[tilemapnum] = 1;
r20746	r20747
1453	1446
1454	1447
1455	1448
1456		static UINT32 cps3_flashmain_r(address_space &space, int which, UINT32 offset, UINT32 mem_mask)
	1449	UINT32 cps3_state::cps3_flashmain_r(address_space &space, int which, UINT32 offset, UINT32 mem_mask)
1457	1450	{
1458		cps3_state *state = space.machine().driver_data<cps3_state>();
1459	1451	UINT32 result = 0;
1460	1452
1461		if (state->m_simm[which][0] == NULL || state->m_simm[which][1] == NULL || state->m_simm[which][2] == NULL || state->m_simm[which][3] == NULL)
	1453	if (m_simm[which][0] == NULL || m_simm[which][1] == NULL || m_simm[which][2] == NULL || m_simm[which][3] == NULL)
1462	1454	return 0xffffffff;
1463	1455
1464	1456	if (ACCESSING_BITS_24_31)   // Flash 1
1465	1457	{
1466	1458	//      logerror("read flash chip %d addr %02x\n", base+0, offset*4 );
1467		result |= (state->m_simm[which][0]->read(offset)<<24);
	1459	result |= (m_simm[which][0]->read(offset)<<24);
1468	1460	}
1469	1461	if (ACCESSING_BITS_16_23)   // Flash 1
1470	1462	{
1471	1463	//      logerror("read flash chip %d addr %02x\n", base+1, offset*4 );
1472		result |= (state->m_simm[which][1]->read(offset)<<16);
	1464	result |= (m_simm[which][1]->read(offset)<<16);
1473	1465	}
1474	1466	if (ACCESSING_BITS_8_15)    // Flash 1
1475	1467	{
1476	1468	//      logerror("read flash chip %d addr %02x\n", base+2, offset*4 );
1477		result |= (state->m_simm[which][2]->read(offset)<<8);
	1469	result |= (m_simm[which][2]->read(offset)<<8);
1478	1470	}
1479	1471	if (ACCESSING_BITS_0_7) // Flash 1
1480	1472	{
1481	1473	//      logerror("read flash chip %d addr %02x\n", base+3, offset*4 );
1482		result |= (state->m_simm[which][3]->read(offset)<<0);
	1474	result |= (m_simm[which][3]->read(offset)<<0);
1483	1475	}
1484	1476
1485	1477	//  if (base==4) logerror("read flash chips addr %02x returning %08x\n", offset*4, result );
r20746	r20747
1509	1501	return retvalue;
1510	1502	}
1511	1503
1512		static void cps3_flashmain_w(running_machine &machine, int which, UINT32 offset, UINT32 data, UINT32 mem_mask)
	1504	void cps3_state::cps3_flashmain_w(int which, UINT32 offset, UINT32 data, UINT32 mem_mask)
1513	1505	{
1514		cps3_state *state = machine.driver_data<cps3_state>();
1515	1506	int command;
1516	1507
1517		if (state->m_simm[which][0] == NULL || state->m_simm[which][1] == NULL || state->m_simm[which][2] == NULL || state->m_simm[which][3] == NULL)
	1508	if (m_simm[which][0] == NULL || m_simm[which][1] == NULL || m_simm[which][2] == NULL || m_simm[which][3] == NULL)
1518	1509	return;
1519	1510
1520	1511	if (ACCESSING_BITS_24_31)   // Flash 1
1521	1512	{
1522	1513	command = (data >> 24) & 0xff;
1523		logerror("write to flash chip %s addr %02x cmd %02x\n", state->m_simm[which][0]->tag(), offset, command);
1524		state->m_simm[which][0]->write(offset, command);
	1514	logerror("write to flash chip %s addr %02x cmd %02x\n", m_simm[which][0]->tag(), offset, command);
	1515	m_simm[which][0]->write(offset, command);
1525	1516	}
1526	1517	if (ACCESSING_BITS_16_23)   // Flash 2
1527	1518	{
1528	1519	command = (data >> 16) & 0xff;
1529		logerror("write to flash chip %s addr %02x cmd %02x\n", state->m_simm[which][1]->tag(), offset, command);
1530		state->m_simm[which][1]->write(offset, command);
	1520	logerror("write to flash chip %s addr %02x cmd %02x\n", m_simm[which][1]->tag(), offset, command);
	1521	m_simm[which][1]->write(offset, command);
1531	1522	}
1532	1523	if (ACCESSING_BITS_8_15)    // Flash 2
1533	1524	{
1534	1525	command = (data >> 8) & 0xff;
1535		logerror("write to flash chip %s addr %02x cmd %02x\n", state->m_simm[which][2]->tag(), offset, command);
1536		state->m_simm[which][2]->write(offset, command);
	1526	logerror("write to flash chip %s addr %02x cmd %02x\n", m_simm[which][2]->tag(), offset, command);
	1527	m_simm[which][2]->write(offset, command);
1537	1528	}
1538	1529	if (ACCESSING_BITS_0_7) // Flash 2
1539	1530	{
1540	1531	command = (data >> 0) & 0xff;
1541		logerror("write to flash chip %s addr %02x cmd %02x\n", state->m_simm[which][3]->tag(), offset, command);
1542		state->m_simm[which][3]->write(offset, command);
	1532	logerror("write to flash chip %s addr %02x cmd %02x\n", m_simm[which][3]->tag(), offset, command);
	1533	m_simm[which][3]->write(offset, command);
1543	1534	}
1544	1535
1545	1536	/* copy data into regions to execute from */
1546	1537	{
1547		UINT32* romdata =  (UINT32*)state->m_user4region;
1548		UINT32* romdata2 = (UINT32*)state->m_decrypted_gamerom;
	1538	UINT32* romdata =  (UINT32*)m_user4region;
	1539	UINT32* romdata2 = (UINT32*)m_decrypted_gamerom;
1549	1540	int real_offset = 0;
1550	1541	UINT32 newdata;
1551	1542
r20746	r20747
1558	1549	real_offset += 0x800000;
1559	1550	}
1560	1551
1561		newdata = (state->m_simm[which][0]->read_raw(offset)<<24) |
1562		(state->m_simm[which][1]->read_raw(offset)<<16) |
1563		(state->m_simm[which][2]->read_raw(offset)<<8) |
1564		(state->m_simm[which][3]->read_raw(offset)<<0);
	1552	newdata = (m_simm[which][0]->read_raw(offset)<<24) |
	1553	(m_simm[which][1]->read_raw(offset)<<16) |
	1554	(m_simm[which][2]->read_raw(offset)<<8) |
	1555	(m_simm[which][3]->read_raw(offset)<<0);
1565	1556
1566		//printf("%08x %08x %08x %08x %08x\n",offset, romdata2[offset], romdata[offset], newdata,  newdata^cps3_mask(0x6000000+real_offset, state->m_key1, state->m_key2)  );
	1557	//printf("%08x %08x %08x %08x %08x\n",offset, romdata2[offset], romdata[offset], newdata,  newdata^cps3_mask(0x6000000+real_offset, m_key1, m_key2)  );
1567	1558
1568	1559	romdata[offset] = newdata;
1569		romdata2[offset] = newdata^cps3_mask(0x6000000+real_offset, state->m_key1, state->m_key2);
	1560	romdata2[offset] = newdata^cps3_mask(0x6000000+real_offset, m_key1, m_key2);
1570	1561	}
1571	1562	}
1572	1563
1573	1564	WRITE32_MEMBER(cps3_state::cps3_flash1_w)
1574	1565	{
1575		cps3_flashmain_w(machine(),0,offset,data,mem_mask);
	1566	cps3_flashmain_w(0,offset,data,mem_mask);
1576	1567	}
1577	1568
1578	1569	WRITE32_MEMBER(cps3_state::cps3_flash2_w)
1579	1570	{
1580		cps3_flashmain_w(machine(),1,offset,data,mem_mask);
	1571	cps3_flashmain_w(1,offset,data,mem_mask);
1581	1572	}
1582	1573
1583	1574	WRITE32_MEMBER(cps3_state::cram_gfxflash_bank_w)
r20746	r20747
1778	1769
1779	1770	//if (m_paldma_fade!=0) printf("%08x\n",m_paldma_fade);
1780	1771
1781		cps3_set_mame_colours(machine(), (m_paldma_dest+i)^1, coldata, m_paldma_fade);
	1772	cps3_set_mame_colours((m_paldma_dest+i)^1, coldata, m_paldma_fade);
1782	1773	}
1783	1774
1784	1775
r20746	r20747
1797	1788
1798	1789
1799	1790
1800		static UINT32 process_byte( running_machine &machine, UINT8 real_byte, UINT32 destination, int max_length )
	1791	UINT32 cps3_state::process_byte( UINT8 real_byte, UINT32 destination, int max_length )
1801	1792	{
1802		cps3_state *state = machine.driver_data<cps3_state>();
1803		UINT8* dest       = (UINT8*)state->m_char_ram;
	1793	UINT8* dest       = (UINT8*)m_char_ram;
1804	1794
1805	1795	//printf("process byte for destination %08x\n", destination);
1806	1796
r20746	r20747
1811	1801	int tranfercount = 0;
1812	1802
1813	1803	//printf("Set RLE Mode\n");
1814		state->m_rle_length = (real_byte&0x3f)+1;
	1804	m_rle_length = (real_byte&0x3f)+1;
1815	1805
1816		//printf("RLE Operation (length %08x\n", state->m_rle_length );
	1806	//printf("RLE Operation (length %08x\n", m_rle_length );
1817	1807
1818		while (state->m_rle_length)
	1808	while (m_rle_length)
1819	1809	{
1820		dest[((destination+tranfercount)&0x7fffff)^3] = (state->m_last_normal_byte&0x3f);
1821		machine.gfx[1]->mark_dirty(((destination+tranfercount)&0x7fffff)/0x100);
	1810	dest[((destination+tranfercount)&0x7fffff)^3] = (m_last_normal_byte&0x3f);
	1811	machine().gfx[1]->mark_dirty(((destination+tranfercount)&0x7fffff)/0x100);
1822	1812	//printf("RLE WRite Byte %08x, %02x\n", destination+tranfercount, real_byte);
1823	1813
1824	1814	tranfercount++;
1825		state->m_rle_length--;
	1815	m_rle_length--;
1826	1816	max_length--;
1827	1817
1828	1818	if ((destination+tranfercount) > 0x7fffff)  return max_length;
r20746	r20747
1836	1826	{
1837	1827	//printf("Write Normal Data\n");
1838	1828	dest[(destination&0x7fffff)^3] = real_byte;
1839		state->m_last_normal_byte = real_byte;
1840		machine.gfx[1]->mark_dirty((destination&0x7fffff)/0x100);
	1829	m_last_normal_byte = real_byte;
	1830	machine().gfx[1]->mark_dirty((destination&0x7fffff)/0x100);
1841	1831	return 1;
1842	1832	}
1843	1833	}
1844	1834
1845		static void cps3_do_char_dma( running_machine &machine, UINT32 real_source, UINT32 real_destination, UINT32 real_length )
	1835	void cps3_state::cps3_do_char_dma( UINT32 real_source, UINT32 real_destination, UINT32 real_length )
1846	1836	{
1847		cps3_state *state = machine.driver_data<cps3_state>();
1848		UINT8* sourcedata = (UINT8*)state->m_user5region;
	1837	UINT8* sourcedata = (UINT8*)m_user5region;
1849	1838	int length_remaining;
1850	1839
1851		state->m_last_normal_byte = 0;
1852		state->m_rle_length = 0;
	1840	m_last_normal_byte = 0;
	1841	m_rle_length = 0;
1853	1842	length_remaining = real_length;
1854	1843	while (length_remaining)
1855	1844	{
r20746	r20747
1864	1853	UINT32 length_processed;
1865	1854	current_byte &= 0x7f;
1866	1855
1867		real_byte = sourcedata[DMA_XOR((state->m_current_table_address+current_byte*2+0))];
	1856	real_byte = sourcedata[DMA_XOR((m_current_table_address+current_byte*2+0))];
1868	1857	//if (real_byte&0x80) return;
1869		length_processed = process_byte( machine, real_byte, real_destination, length_remaining );
	1858	length_processed = process_byte(real_byte, real_destination, length_remaining );
1870	1859	length_remaining-=length_processed; // subtract the number of bytes the operation has taken
1871	1860	real_destination+=length_processed; // add it onto the destination
1872	1861	if (real_destination>0x7fffff) return;
1873	1862	if (length_remaining<=0) return; // if we've expired, exit
1874	1863
1875		real_byte = sourcedata[DMA_XOR((state->m_current_table_address+current_byte*2+1))];
	1864	real_byte = sourcedata[DMA_XOR((m_current_table_address+current_byte*2+1))];
1876	1865	//if (real_byte&0x80) return;
1877		length_processed = process_byte( machine, real_byte, real_destination, length_remaining );
	1866	length_processed = process_byte(real_byte, real_destination, length_remaining );
1878	1867	length_remaining-=length_processed; // subtract the number of bytes the operation has taken
1879	1868	real_destination+=length_processed; // add it onto the destination
1880	1869	if (real_destination>0x7fffff) return;
r20746	r20747
1883	1872	else
1884	1873	{
1885	1874	UINT32 length_processed;
1886		length_processed = process_byte( machine, current_byte, real_destination, length_remaining );
	1875	length_processed = process_byte(current_byte, real_destination, length_remaining );
1887	1876	length_remaining-=length_processed; // subtract the number of bytes the operation has taken
1888	1877	real_destination+=length_processed; // add it onto the destination
1889	1878	if (real_destination>0x7fffff) return;
r20746	r20747
1894	1883	}
1895	1884	}
1896	1885
1897		static UINT32 ProcessByte8(running_machine &machine,UINT8 b,UINT32 dst_offset)
	1886	UINT32 cps3_state::ProcessByte8(UINT8 b,UINT32 dst_offset)
1898	1887	{
1899		cps3_state *state = machine.driver_data<cps3_state>();
1900		UINT8* destRAM = (UINT8*)state->m_char_ram;
	1888	UINT8* destRAM = (UINT8*)m_char_ram;
1901	1889	int l=0;
1902	1890
1903		if(state->m_lastb==state->m_lastb2) //rle
	1891	if(m_lastb==m_lastb2) //rle
1904	1892	{
1905	1893	int i;
1906	1894	int rle=(b+1)&0xff;
1907	1895
1908	1896	for(i=0;i<rle;++i)
1909	1897	{
1910		destRAM[(dst_offset&0x7fffff)^3] = state->m_lastb;
1911		machine.gfx[1]->mark_dirty((dst_offset&0x7fffff)/0x100);
	1898	destRAM[(dst_offset&0x7fffff)^3] = m_lastb;
	1899	machine().gfx[1]->mark_dirty((dst_offset&0x7fffff)/0x100);
1912	1900
1913	1901	dst_offset++;
1914	1902	++l;
1915	1903	}
1916		state->m_lastb2=0xffff;
	1904	m_lastb2=0xffff;
1917	1905
1918	1906	return l;
1919	1907	}
1920	1908	else
1921	1909	{
1922		state->m_lastb2=state->m_lastb;
1923		state->m_lastb=b;
	1910	m_lastb2=m_lastb;
	1911	m_lastb=b;
1924	1912	destRAM[(dst_offset&0x7fffff)^3] = b;
1925		machine.gfx[1]->mark_dirty((dst_offset&0x7fffff)/0x100);
	1913	machine().gfx[1]->mark_dirty((dst_offset&0x7fffff)/0x100);
1926	1914	return 1;
1927	1915	}
1928	1916	}
1929	1917
1930		static void cps3_do_alt_char_dma( running_machine &machine, UINT32 src, UINT32 real_dest, UINT32 real_length )
	1918	void cps3_state::cps3_do_alt_char_dma( UINT32 src, UINT32 real_dest, UINT32 real_length )
1931	1919	{
1932		cps3_state *state = machine.driver_data<cps3_state>();
1933		UINT8* px = (UINT8*)state->m_user5region;
	1920	UINT8* px = (UINT8*)m_user5region;
1934	1921	UINT32 start = real_dest;
1935	1922	UINT32 ds = real_dest;
1936	1923
1937		state->m_lastb=0xfffe;
1938		state->m_lastb2=0xffff;
	1924	m_lastb=0xfffe;
	1925	m_lastb2=0xffff;
1939	1926
1940	1927	while(1)
1941	1928	{
r20746	r20747
1951	1938	{
1952	1939	UINT8 real_byte;
1953	1940	p&=0x7f;
1954		real_byte = px[DMA_XOR((state->m_current_table_address+p*2+0))];
1955		ds+=ProcessByte8(machine,real_byte,ds);
1956		real_byte = px[DMA_XOR((state->m_current_table_address+p*2+1))];
1957		ds+=ProcessByte8(machine,real_byte,ds);
	1941	real_byte = px[DMA_XOR((m_current_table_address+p*2+0))];
	1942	ds+=ProcessByte8(real_byte,ds);
	1943	real_byte = px[DMA_XOR((m_current_table_address+p*2+1))];
	1944	ds+=ProcessByte8(real_byte,ds);
1958	1945	}
1959	1946	else
1960	1947	{
1961		ds+=ProcessByte8(machine,p,ds);
	1948	ds+=ProcessByte8(p,ds);
1962	1949	}
1963	1950	++src;
1964	1951	ctrl<<=1;
r20746	r20747
1969	1956	}
1970	1957	}
1971	1958
1972		static void cps3_process_character_dma(running_machine &machine, UINT32 address)
	1959	void cps3_state::cps3_process_character_dma(UINT32 address)
1973	1960	{
1974		cps3_state *state = machine.driver_data<cps3_state>();
1975	1961	int i;
1976	1962
1977	1963	//printf("charDMA start:\n");
1978	1964
1979	1965	for (i = 0; i < 0x1000; i += 3)
1980	1966	{
1981		UINT32 dat1 = LITTLE_ENDIANIZE_INT32(state->m_char_ram[i + 0 + (address)]);
1982		UINT32 dat2 = LITTLE_ENDIANIZE_INT32(state->m_char_ram[i + 1 + (address)]);
1983		UINT32 dat3 = LITTLE_ENDIANIZE_INT32(state->m_char_ram[i + 2 + (address)]);
	1967	UINT32 dat1 = LITTLE_ENDIANIZE_INT32(m_char_ram[i + 0 + (address)]);
	1968	UINT32 dat2 = LITTLE_ENDIANIZE_INT32(m_char_ram[i + 1 + (address)]);
	1969	UINT32 dat3 = LITTLE_ENDIANIZE_INT32(m_char_ram[i + 2 + (address)]);
1984	1970	UINT32 real_source      = (dat3 << 1) - 0x400000;
1985	1971	UINT32 real_destination =  dat2 << 3;
1986	1972	UINT32 real_length      = (((dat1 & 0x001fffff) + 1) << 3);
r20746	r20747
1995	1981	/* Sets a table used by the decompression routines */
1996	1982	{
1997	1983	/* We should probably copy this, but a pointer to it is fine for our purposes as the data doesn't change */
1998		state->m_current_table_address = real_source;
	1984	m_current_table_address = real_source;
1999	1985	}
2000		machine.device("maincpu")->execute().set_input_line(10, ASSERT_LINE);
	1986	machine().device("maincpu")->execute().set_input_line(10, ASSERT_LINE);
2001	1987	}
2002	1988	else if  ((dat1 & 0x00e00000) == 0x00400000)
2003	1989	{
2004	1990	/* 6bpp DMA decompression
2005	1991	- this is used for the majority of sprites and backgrounds */
2006		cps3_do_char_dma( machine, real_source, real_destination, real_length );
2007		machine.device("maincpu")->execute().set_input_line(10, ASSERT_LINE);
	1992	cps3_do_char_dma(real_source, real_destination, real_length );
	1993	machine().device("maincpu")->execute().set_input_line(10, ASSERT_LINE);
2008	1994
2009	1995	}
2010	1996	else if  ((dat1 & 0x00e00000) == 0x00600000)
2011	1997	{
2012	1998	/* 8bpp DMA decompression
2013	1999	- this is used on SFIII NG Sean's Stage ONLY */
2014		cps3_do_alt_char_dma( machine, real_source, real_destination, real_length);
2015		machine.device("maincpu")->execute().set_input_line(10, ASSERT_LINE);
	2000	cps3_do_alt_char_dma(real_source, real_destination, real_length);
	2001	machine().device("maincpu")->execute().set_input_line(10, ASSERT_LINE);
2016	2002	}
2017	2003	else
2018	2004	{
r20746	r20747
2051	2037	list_address = (m_chardma_source | ((m_chardma_other&0x003f0000)));
2052	2038
2053	2039	//printf("chardma_w activated %08x %08x (address = cram %08x)\n", m_chardma_source, m_chardma_other, list_address*4 );
2054		cps3_process_character_dma(machine(), list_address);
	2040	cps3_process_character_dma(list_address);
2055	2041	}
2056	2042	else
2057	2043	{
r20746	r20747
2096	2082
2097	2083	if (ACCESSING_BITS_24_31)
2098	2084	{
2099		cps3_set_mame_colours(machine(), offset*2, (data & 0xffff0000) >> 16, 0);
	2085	cps3_set_mame_colours(offset*2, (data & 0xffff0000) >> 16, 0);
2100	2086	}
2101	2087
2102	2088	if (ACCESSING_BITS_0_7)
2103	2089	{
2104		cps3_set_mame_colours(machine(), offset*2+1, (data & 0x0000ffff) >> 0, 0);
	2090	cps3_set_mame_colours(offset*2+1, (data & 0x0000ffff) >> 0, 0);
2105	2091	}
2106	2092	}
2107	2093
r20746	r20747
2268	2254	m_current_table_address = -1;
2269	2255
2270	2256	// copy data from flashroms back into user regions + decrypt into regions we execute/draw from.
2271		copy_from_nvram(machine());
	2257	copy_from_nvram();
2272	2258	}
2273	2259
2274	2260
2275	2261
2276	2262	// make a copy in the regions we execute code / draw gfx from
2277		static void copy_from_nvram(running_machine &machine)
	2263	void cps3_state::copy_from_nvram()
2278	2264	{
2279		cps3_state *state = machine.driver_data<cps3_state>();
2280		UINT32* romdata = (UINT32*)state->m_user4region;
2281		UINT32* romdata2 = (UINT32*)state->m_decrypted_gamerom;
	2265	UINT32* romdata = (UINT32*)m_user4region;
	2266	UINT32* romdata2 = (UINT32*)m_decrypted_gamerom;
2282	2267	int i;
2283	2268	/* copy + decrypt program roms which have been loaded from flashroms/nvram */
2284	2269	for (i=0;i<0x800000;i+=4)
2285	2270	{
2286	2271	UINT32 data;
2287	2272
2288		data = ((state->m_simm[0][0]->read_raw(i/4)<<24) | (state->m_simm[0][1]->read_raw(i/4)<<16) | (state->m_simm[0][2]->read_raw(i/4)<<8) | (state->m_simm[0][3]->read_raw(i/4)<<0));
	2273	data = ((m_simm[0][0]->read_raw(i/4)<<24) | (m_simm[0][1]->read_raw(i/4)<<16) | (m_simm[0][2]->read_raw(i/4)<<8) | (m_simm[0][3]->read_raw(i/4)<<0));
2289	2274
2290		//  printf("%08x %08x %08x %08x\n",romdata[i/4],data, romdata2[i/4], data ^ cps3_mask(i+0x6000000, state->m_key1, state->m_key2));
	2275	//  printf("%08x %08x %08x %08x\n",romdata[i/4],data, romdata2[i/4], data ^ cps3_mask(i+0x6000000, m_key1, m_key2));
2291	2276	romdata[i/4] = data;
2292		romdata2[i/4] = data ^ cps3_mask(i+0x6000000, state->m_key1, state->m_key2);
	2277	romdata2[i/4] = data ^ cps3_mask(i+0x6000000, m_key1, m_key2);
2293	2278
2294	2279	}
2295	2280
2296	2281	romdata  += 0x800000/4;
2297	2282	romdata2 += 0x800000/4;
2298	2283
2299		if (state->m_simm[1][0] != NULL)
	2284	if (m_simm[1][0] != NULL)
2300	2285	for (i=0;i<0x800000;i+=4)
2301	2286	{
2302	2287	UINT32 data;
2303	2288
2304		data = ((state->m_simm[1][0]->read_raw(i/4)<<24) | (state->m_simm[1][1]->read_raw(i/4)<<16) | (state->m_simm[1][2]->read_raw(i/4)<<8) | (state->m_simm[1][3]->read_raw(i/4)<<0));
	2289	data = ((m_simm[1][0]->read_raw(i/4)<<24) | (m_simm[1][1]->read_raw(i/4)<<16) | (m_simm[1][2]->read_raw(i/4)<<8) | (m_simm[1][3]->read_raw(i/4)<<0));
2305	2290
2306		//  printf("%08x %08x %08x %08x\n",romdata[i/4],data, romdata2[i/4],  data ^ cps3_mask(i+0x6800000, state->m_key1, state->m_key2) );
	2291	//  printf("%08x %08x %08x %08x\n",romdata[i/4],data, romdata2[i/4],  data ^ cps3_mask(i+0x6800000, m_key1, m_key2) );
2307	2292	romdata[i/4] = data;
2308		romdata2[i/4] = data ^ cps3_mask(i+0x6800000, state->m_key1, state->m_key2);
	2293	romdata2[i/4] = data ^ cps3_mask(i+0x6800000, m_key1, m_key2);
2309	2294	}
2310	2295
2311	2296	/* copy gfx from loaded flashroms to user reigon 5, where it's used */
r20746	r20747
2314	2299	int flashnum = 0;
2315	2300	int countoffset = 0;
2316	2301
2317		romdata = (UINT32*)state->m_user5region;
	2302	romdata = (UINT32*)m_user5region;
2318	2303	for (thebase = 0;thebase < len/2; thebase+=0x200000)
2319	2304	{
2320	2305	//  printf("flashnums %d. %d\n",flashnum, flashnum+1);
2321	2306
2322		fujitsu_29f016a_device *flash0 = state->m_simm[2 + flashnum/8][flashnum % 8 + 0];
2323		fujitsu_29f016a_device *flash1 = state->m_simm[2 + flashnum/8][flashnum % 8 + 1];
	2307	fujitsu_29f016a_device *flash0 = m_simm[2 + flashnum/8][flashnum % 8 + 0];
	2308	fujitsu_29f016a_device *flash1 = m_simm[2 + flashnum/8][flashnum % 8 + 1];
2324	2309	if (flash0 == NULL || flash1 == NULL)
2325	2310	continue;
2326	2311	if (flash0 != NULL && flash1 != NULL)
r20746	r20747
2346	2331	/*
2347	2332	{
2348	2333	FILE *fp;
2349		const char *gamename = machine.system().name;
	2334	const char *gamename = machine().system().name;
2350	2335	char filename[256];
2351	2336	sprintf(filename, "%s_bios.dump", gamename);
2352	2337
r20746	r20747
2387	2372	if (src<0x80000)
2388	2373	{
2389	2374	int offs = (src&0x07ffff)>>2;
2390		data = data ^ cps3_mask(offs*4, state->m_key1, state->m_key2);
	2375	data = data ^ state->cps3_mask(offs*4, state->m_key1, state->m_key2);
2391	2376	}
2392	2377	else if (src>=0x6000000 && src<0x6800000)
2393	2378	{
2394	2379	int offs = (src&0x07fffff)>>2;
2395		if (!state->m_altEncryption) data = data ^ cps3_mask(0x6000000+offs*4, state->m_key1, state->m_key2);
	2380	if (!state->m_altEncryption) data = data ^ state->cps3_mask(0x6000000+offs*4, state->m_key1, state->m_key2);
2396	2381	}
2397	2382	else if (src>=0x6800000 && src<0x7000000)
2398	2383	{
2399	2384	int offs = (src&0x07fffff)>>2;
2400		if (!state->m_altEncryption) data = data ^ cps3_mask(0x6800000+offs*4, state->m_key1, state->m_key2);
	2385	if (!state->m_altEncryption) data = data ^ state->cps3_mask(0x6800000+offs*4, state->m_key1, state->m_key2);
2401	2386	}
2402	2387	else
2403	2388	{

trunk/src/mame/drivers/cloud9.c

r20746	r20747
110	110	*
111	111	*************************************/
112	112
113		INLINE void schedule_next_irq(running_machine &machine, int curscanline)
	113	inline void cloud9_state::schedule_next_irq(int curscanline)
114	114	{
115		cloud9_state *state = machine.driver_data<cloud9_state>();
116	115
117	116	/* IRQ is clocked by /32V, so every 64 scanlines */
118	117	curscanline = (curscanline + 64) & 255;
119	118
120	119	/* next one at the start of this scanline */
121		state->m_irq_timer->adjust(machine.primary_screen->time_until_pos(curscanline), curscanline);
	120	m_irq_timer->adjust(machine().primary_screen->time_until_pos(curscanline), curscanline);
122	121	}
123	122
124	123
r20746	r20747
135	134	machine().primary_screen->update_partial(machine().primary_screen->vpos());
136	135
137	136	/* find the next edge */
138		schedule_next_irq(machine(), param);
	137	schedule_next_irq(param);
139	138	}
140	139
141	140
r20746	r20747
182	181	/* create a timer for IRQs and set up the first callback */
183	182	m_irq_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(cloud9_state::clock_irq),this));
184	183	m_irq_state = 0;
185		schedule_next_irq(machine(), 0-64);
	184	schedule_next_irq(0-64);
186	185
187	186	/* setup for save states */
188	187	save_item(NAME(m_irq_state));

trunk/src/mame/drivers/crshrace.c

r20746	r20747
570	570
571	571
572	572	#ifdef UNUSED_FUNCTION
573		void crshrace_patch_code( UINT16 offset )
	573	void crshrace_state::crshrace_patch_code( UINT16 offset )
574	574	{
575	575	/* A hack which shows 3 player mode in code which is disabled */
576		UINT16 *RAM = (UINT16 *)machine.root_device().memregion("maincpu")->base();
	576	UINT16 *RAM = (UINT16 *)machine().root_device().memregion("maincpu")->base();
577	577	RAM[(offset + 0)/2] = 0x4e71;
578	578	RAM[(offset + 2)/2] = 0x4e71;
579	579	RAM[(offset + 4)/2] = 0x4e71;

trunk/src/mame/drivers/crospang.c

r20746	r20747
553	553	ROM_END
554	554
555	555
556		static void tumblepb_gfx1_rearrange(running_machine &machine)
	556	void crospang_state::tumblepb_gfx1_rearrange()
557	557	{
558		UINT8 *rom = machine.root_device().memregion("gfx1")->base();
559		int len = machine.root_device().memregion("gfx1")->bytes();
	558	UINT8 *rom = machine().root_device().memregion("gfx1")->base();
	559	int len = machine().root_device().memregion("gfx1")->bytes();
560	560	int i;
561	561
562	562	/* gfx data is in the wrong order */
r20746	r20747
576	576
577	577	DRIVER_INIT_MEMBER(crospang_state,crospang)
578	578	{
579		tumblepb_gfx1_rearrange(machine());
	579	tumblepb_gfx1_rearrange();
580	580	}
581	581
582	582	GAME( 1998, crospang, 0, crospang, crospang, crospang_state, crospang, ROT0, "F2 System", "Cross Pang", GAME_SUPPORTS_SAVE )

trunk/src/mame/drivers/galaxia.c

r20746	r20747
70	70	INTERRUPT_GEN_MEMBER(galaxia_state::galaxia_interrupt)
71	71	{
72	72	device.execute().set_input_line_and_vector(0, HOLD_LINE, 0x03);
73		cvs_scroll_stars(machine());
	73	cvs_scroll_stars();
74	74	}
75	75
76	76

trunk/src/mame/drivers/ccastles.c

r20746	r20747
138	138	*
139	139	*************************************/
140	140
141		INLINE void schedule_next_irq( running_machine &machine, int curscanline )
	141	inline void ccastles_state::schedule_next_irq( int curscanline )
142	142	{
143		ccastles_state *state = machine.driver_data<ccastles_state>();
144	143
145	144	/* scan for a rising edge on the IRQCK signal */
146	145	for (curscanline++; ; curscanline = (curscanline + 1) & 0xff)
147		if ((state->m_syncprom[(curscanline - 1) & 0xff] & 8) == 0 && (state->m_syncprom[curscanline] & 8) != 0)
	146	if ((m_syncprom[(curscanline - 1) & 0xff] & 8) == 0 && (m_syncprom[curscanline] & 8) != 0)
148	147	break;
149	148
150	149	/* next one at the start of this scanline */
151		state->m_irq_timer->adjust(machine.primary_screen->time_until_pos(curscanline), curscanline);
	150	m_irq_timer->adjust(machine().primary_screen->time_until_pos(curscanline), curscanline);
152	151	}
153	152
154	153
r20746	r20747
165	164	machine().primary_screen->update_partial(machine().primary_screen->vpos());
166	165
167	166	/* find the next edge */
168		schedule_next_irq(machine(), param);
	167	schedule_next_irq(param);
169	168	}
170	169
171	170
r20746	r20747
215	214	/* create a timer for IRQs and set up the first callback */
216	215	m_irq_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(ccastles_state::clock_irq),this));
217	216	m_irq_state = 0;
218		schedule_next_irq(machine(), 0);
	217	schedule_next_irq(0);
219	218
220	219	/* setup for save states */
221	220	save_item(NAME(m_irq_state));

trunk/src/mame/drivers/cabal.c

r20746	r20747
832	832
833	833
834	834
835		static void seibu_sound_bootleg(running_machine &machine,const char *cpu,int length)
	835	void cabal_state::seibu_sound_bootleg(const char *cpu,int length)
836	836	{
837		address_space &space = machine.device(cpu)->memory().space(AS_PROGRAM);
838		UINT8 *decrypt = auto_alloc_array(machine, UINT8, length);
839		UINT8 *rom = machine.root_device().memregion(cpu)->base();
	837	address_space &space = machine().device(cpu)->memory().space(AS_PROGRAM);
	838	UINT8 *decrypt = auto_alloc_array(machine(), UINT8, length);
	839	UINT8 *rom = machine().root_device().memregion(cpu)->base();
840	840
841	841	space.set_decrypted_region(0x0000, (length < 0x10000) ? (length - 1) : 0x1fff, decrypt);
842	842
843	843	memcpy(decrypt, rom+length, length);
844	844
845	845	if (length > 0x10000)
846		machine.root_device().membank("bank1")->configure_decrypted_entries(0, (length - 0x10000) / 0x8000, decrypt + 0x10000, 0x8000);
	846	machine().root_device().membank("bank1")->configure_decrypted_entries(0, (length - 0x10000) / 0x8000, decrypt + 0x10000, 0x8000);
847	847	}
848	848
849	849
r20746	r20747
857	857
858	858	DRIVER_INIT_MEMBER(cabal_state,cabalbl2)
859	859	{
860		seibu_sound_bootleg(machine(),"audiocpu",0x2000);
	860	seibu_sound_bootleg("audiocpu",0x2000);
861	861	seibu_adpcm_decrypt(machine(),"adpcm1");
862	862	seibu_adpcm_decrypt(machine(),"adpcm2");
863	863	}

trunk/src/mame/drivers/compgolf.c

r20746	r20747
333	333	*
334	334	*************************************/
335	335
336		static void compgolf_expand_bg(running_machine &machine)
	336	void compgolf_state::compgolf_expand_bg()
337	337	{
338		UINT8 *GFXDST = machine.root_device().memregion("gfx2")->base();
339		UINT8 *GFXSRC = machine.root_device().memregion("gfx4")->base();
	338	UINT8 *GFXDST = machine().root_device().memregion("gfx2")->base();
	339	UINT8 *GFXSRC = machine().root_device().memregion("gfx4")->base();
340	340
341	341	int x;
342	342
r20746	r20747
350	350	DRIVER_INIT_MEMBER(compgolf_state,compgolf)
351	351	{
352	352	machine().root_device().membank("bank1")->configure_entries(0, 2, machine().root_device().memregion("user1")->base(), 0x4000);
353		compgolf_expand_bg(machine());
	353	compgolf_expand_bg();
354	354	}
355	355
356	356

trunk/src/mame/drivers/cdi.c

r20746	r20747
35	35	#include "imagedev/chd_cd.h"
36	36
37	37	#if ENABLE_VERBOSE_LOG
38		INLINE void verboselog(running_machine &machine, int n_level, const char *s_fmt, ...)
	38	INLINE ::void verboselog(int n_level, const char *s_fmt, ...)
39	39	{
40	40	if( VERBOSE_LEVEL >= n_level )
41	41	{
r20746	r20747
44	44	va_start( v, s_fmt );
45	45	vsprintf( buf, s_fmt, v );
46	46	va_end( v );
47		logerror( "%08x: %s", machine.device("maincpu")->safe_pc(), buf );
	47	logerror( "%08x: %s", machine().device("maincpu")->safe_pc(), buf );
48	48	}
49	49	}
50	50	#else

trunk/src/mame/drivers/crbaloon.c

r20746	r20747
44	44	#define LOG_PC3092      0
45	45
46	46
47		static void pc3092_reset(void)
	47	void crbaloon_state::pc3092_reset(void)
48	48	{
49	49	/* nothing yet */
50	50	}
51	51
52	52
53		static void pc3092_update(running_machine &machine)
	53	void crbaloon_state::pc3092_update()
54	54	{
55		crbaloon_state *state = machine.driver_data<crbaloon_state>();
56		state->flip_screen_set((state->m_pc3092_data[1] & 0x01) ? TRUE : FALSE);
	55	flip_screen_set((m_pc3092_data[1] & 0x01) ? TRUE : FALSE);
57	56	}
58	57
59	58
r20746	r20747
63	62
64	63	if (LOG_PC3092) logerror("%04X:  write PC3092 #%d = 0x%02x\n", space.device().safe_pc(), offset, m_pc3092_data[offset]);
65	64
66		pc3092_update(machine());
	65	pc3092_update();
67	66	}
68	67
69	68
r20746	r20747
107	106	#define LOG_PC3259      0
108	107
109	108
110		static void pc3259_update(void)
	109	void crbaloon_state::pc3259_update(void)
111	110	{
112	111	/* nothing yet */
113	112	}
r20746	r20747
118	117	UINT8 ret = 0;
119	118	UINT8 reg = offset >> 2;
120	119
121		UINT16 collision_address = crbaloon_get_collision_address(machine());
	120	UINT16 collision_address = crbaloon_get_collision_address();
122	121	int collided = (collision_address != 0xffff);
123	122
124	123	switch (reg)
r20746	r20747
160	159
161	160	/* D0 - interrupt enable - also goes to PC3259 as /HTCTRL */
162	161	m_irq_mask = data & 0x01;
163		crbaloon_set_clear_collision_address(machine(), (data & 0x01) ? TRUE : FALSE);
	162	crbaloon_set_clear_collision_address((data & 0x01) ? TRUE : FALSE);
164	163
165	164	/* D1 - SOUND STOP */
166	165	machine().sound().system_enable((data & 0x02) ? TRUE : FALSE);

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team