Previous

199869 Revisions

Next

r45068 Sunday 21st February, 2016 at 02:03:29 UTC by Ryan Holtz
Final fixups, get sliders working again, nw

[src/emu/ui]	ui.cpp ui.h
[src/osd/modules]	osdwindow.cpp osdwindow.h
[src/osd/modules/lib]	osdobj_common.cpp
[src/osd/modules/render]	draw13.cpp draw13.h drawbgfx.h drawd3d.cpp drawd3d.h drawgdi.h drawnone.h drawogl.cpp drawogl.h drawsdl.cpp drawsdl.h
[src/osd/modules/render/d3d]	d3dhlsl.cpp d3dhlsl.h
[src/osd/sdl]	video.cpp video.h window.cpp
[src/osd/windows]	video.cpp window.cpp winmain.h

trunk/src/emu/ui/ui.cpp

r253579	r253580
1954	1954	state->incval = incval;
1955	1955	state->update = update;
1956	1956	state->arg = arg;
	1957	state->hidden = false;
	1958	state->id = -1;
1957	1959	strcpy(state->description, title);
1958	1960
1959	1961	return state;

trunk/src/emu/ui/ui.h

r253579	r253580
104	104	INT32           maxval;             /* maximum value */
105	105	INT32           incval;             /* increment value */
106	106	bool         hidden;            /* hidden or not */
	107	INT32         id;               /* unique identifier */
107	108	char          description[1];     /* textual description */
108	109	};
109	110

trunk/src/osd/modules/lib/osdobj_common.cpp

r253579	r253580
492	492
493	493	slider_state* osd_common_t::get_slider_list()
494	494	{
	495	printf("Core get_slider_list\n");
495	496	return nullptr;
496	497	}
497	498

trunk/src/osd/modules/osdwindow.cpp

r253579	r253580
16	16
17	17	#include "render/drawnone.h"
18	18	#include "render/drawbgfx.h"
	19	#if (USE_OPENGL)
19	20	#include "render/drawogl.h"
20		#if OSD_WINDOWS
	21	#endif
	22	#ifdef OSD_WINDOWS
21	23	#include "render/drawgdi.h"
22	24	#include "render/drawd3d.h"
23	25	#else
r253579	r253580
29	31	{
30	32	switch(mode)
31	33	{
	34	#ifdef OSD_WINDOWS
32	35	case VIDEO_MODE_NONE:
33	36	return new renderer_none(window);
	37	#endif
34	38	case VIDEO_MODE_BGFX:
35	39	return new renderer_bgfx(window);
36	40	#if (USE_OPENGL)
37	41	case VIDEO_MODE_OPENGL:
38	42	return new renderer_ogl(window);
39	43	#endif
40		#if OSD_WINDOWS
	44	#ifdef OSD_WINDOWS
41	45	case VIDEO_MODE_GDI:
42	46	return new renderer_gdi(window);
43	47	case VIDEO_MODE_D3D:

trunk/src/osd/modules/osdwindow.h

r253579	r253580
12	12	#include "emu.h"
13	13	#include "ui/ui.h"
14	14
	15	#ifdef OSD_SDL
	16	// standard SDL headers
	17	#include "sdlinc.h"
	18	#endif
	19
15	20	//============================================================
16	21	//  TYPE DEFINITIONS
17	22	//============================================================
r253579	r253580
21	26
22	27	enum
23	28	{
24		VIDEO_MODE_NONE,
	29	VIDEO_MODE_NONE = 0,
25	30	VIDEO_MODE_GDI,
26	31	VIDEO_MODE_BGFX,
27	32	#if (USE_OPENGL)
r253579	r253580
29	34	#endif
30	35	VIDEO_MODE_SDL2ACCEL,
31	36	VIDEO_MODE_D3D,
32		VIDEO_MODE_SOFT
	37	VIDEO_MODE_SOFT,
	38
	39	VIDEO_MODE_COUNT
33	40	};
34	41
35	42	class osd_dim
r253579	r253580
205	212	static const int FLAG_NEEDS_ASYNCBLIT       = 0x0200;
206	213
207	214	osd_renderer(osd_window *window, const int flags)
208		: m_window(window), m_flags(flags) { }
	215	: m_sliders_dirty(false), m_window(window), m_flags(flags) { }
209	216
210	217	virtual ~osd_renderer() { }
211	218
r253579	r253580
219	226	/* Interface to be implemented by render code */
220	227
221	228	virtual int create() = 0;
222		virtual int init(running_machine &machine) = 0;
223	229	virtual render_primitive_list *get_primitives() = 0;
224	230
225	231	virtual slider_state* get_slider_list() { return nullptr; }
r253579	r253580
228	234	virtual void save() { };
229	235	virtual void record() { };
230	236	virtual void toggle_fsfx() { };
	237	virtual bool sliders_dirty() { return m_sliders_dirty; }
231	238
232	239	static osd_renderer* make_for_type(int mode, osd_window *window, int extra_flags = FLAG_NONE);
233	240
234	241	protected:
235	242	/* Internal flags */
236	243	static const int FI_CHANGED                 = 0x010000;
	244	bool      m_sliders_dirty;
237	245
238	246	private:
239	247	osd_window   *m_window;

trunk/src/osd/modules/render/d3d/d3dhlsl.cpp

r253579	r253580
2206	2206	//  be done in a more ideal way.
2207	2207	//============================================================
2208	2208
2209		static slider_state *slider_alloc(running_machine &machine, const char *title, INT32 minval, INT32 defval, INT32 maxval, INT32 incval, slider_update update, void *arg)
	2209	static slider_state *slider_alloc(running_machine &machine, int id, const char *title, INT32 minval, INT32 defval, INT32 maxval, INT32 incval, slider_update update, void *arg)
2210	2210	{
2211	2211	int size = sizeof(slider_state) + strlen(title);
2212	2212	slider_state *state = (slider_state *)auto_alloc_array_clear(machine, UINT8, size);
r253579	r253580
2218	2218	state->update = update;
2219	2219	state->arg = arg;
2220	2220	state->hidden = false;
	2221	state->id = id;
2221	2222	strcpy(state->description, title);
2222	2223
2223	2224	return state;
r253579	r253580
2845	2846
2846	2847	hlsl_options shaders::last_options = { false };
2847	2848
	2849	enum slider_option
	2850	{
	2851	SLIDER_VECTOR_ATTENUATION = 0,
	2852	SLIDER_VECTOR_LENGTH_MAX,
	2853	SLIDER_SHADOW_MASK_TILE_MODE,
	2854	SLIDER_SHADOW_MASK_ALPHA,
	2855	SLIDER_SHADOW_MASK_X_COUNT,
	2856	SLIDER_SHADOW_MASK_Y_COUNT,
	2857	SLIDER_SHADOW_MASK_U_SIZE,
	2858	SLIDER_SHADOW_MASK_V_SIZE,
	2859	SLIDER_SHADOW_MASK_U_OFFSET,
	2860	SLIDER_SHADOW_MASK_V_OFFSET,
	2861	SLIDER_CURVATURE,
	2862	SLIDER_ROUND_CORNER,
	2863	SLIDER_SMOOTH_BORDER,
	2864	SLIDER_REFLECTION,
	2865	SLIDER_VIGNETTING,
	2866	SLIDER_SCANLINE_ALPHA,
	2867	SLIDER_SCANLINE_SCALE,
	2868	SLIDER_SCANLINE_HEIGHT,
	2869	SLIDER_SCANLINE_BRIGHT_SCALE,
	2870	SLIDER_SCANLINE_BRIGHT_OFFSET,
	2871	SLIDER_SCANLINE_JITTER,
	2872	SLIDER_HUM_BAR_ALPHA,
	2873	SLIDER_DEFOCUS_X,
	2874	SLIDER_DEFOCUS_Y,
	2875	SLIDER_RED_CONVERGE_X,
	2876	SLIDER_RED_CONVERGE_Y,
	2877	SLIDER_GREEN_CONVERGE_X,
	2878	SLIDER_GREEN_CONVERGE_Y,
	2879	SLIDER_BLUE_CONVERGE_X,
	2880	SLIDER_BLUE_CONVERGE_Y,
	2881	SLIDER_RED_RADIAL_CONVERGE_X,
	2882	SLIDER_RED_RADIAL_CONVERGE_Y,
	2883	SLIDER_GREEN_RADIAL_CONVERGE_X,
	2884	SLIDER_GREEN_RADIAL_CONVERGE_Y,
	2885	SLIDER_BLUE_RADIAL_CONVERGE_X,
	2886	SLIDER_BLUE_RADIAL_CONVERGE_Y,
	2887	SLIDER_RED_FROM_R,
	2888	SLIDER_RED_FROM_G,
	2889	SLIDER_RED_FROM_B,
	2890	SLIDER_GREEN_FROM_R,
	2891	SLIDER_GREEN_FROM_G,
	2892	SLIDER_GREEN_FROM_B,
	2893	SLIDER_BLUE_FROM_R,
	2894	SLIDER_BLUE_FROM_G,
	2895	SLIDER_BLUE_FROM_B,
	2896	SLIDER_SATURATION,
	2897	SLIDER_RED_OFFSET,
	2898	SLIDER_GREEN_OFFSET,
	2899	SLIDER_BLUE_OFFSET,
	2900	SLIDER_RED_SCALE,
	2901	SLIDER_GREEN_SCALE,
	2902	SLIDER_BLUE_SCALE,
	2903	SLIDER_RED_POWER,
	2904	SLIDER_GREEN_POWER,
	2905	SLIDER_BLUE_POWER,
	2906	SLIDER_RED_FLOOR,
	2907	SLIDER_GREEN_FLOOR,
	2908	SLIDER_BLUE_FLOOR,
	2909	SLIDER_RED_PHOSPHOR,
	2910	SLIDER_GREEN_PHOSPHOR,
	2911	SLIDER_BLUE_PHOSPHOR,
	2912	SLIDER_BLOOM_BLEND_MODE,
	2913	SLIDER_BLOOM_SCALE,
	2914	SLIDER_BLOOM_RED_OVERDRIVE,
	2915	SLIDER_BLOOM_GREEN_OVERDRIVE,
	2916	SLIDER_BLOOM_BLUE_OVERDRIVE,
	2917	SLIDER_BLOOM_LVL0_SCALE,
	2918	SLIDER_BLOOM_LVL1_SCALE,
	2919	SLIDER_BLOOM_LVL2_SCALE,
	2920	SLIDER_BLOOM_LVL3_SCALE,
	2921	SLIDER_BLOOM_LVL4_SCALE,
	2922	SLIDER_BLOOM_LVL5_SCALE,
	2923	SLIDER_BLOOM_LVL6_SCALE,
	2924	SLIDER_BLOOM_LVL7_SCALE,
	2925	SLIDER_BLOOM_LVL8_SCALE,
	2926	SLIDER_BLOOM_LVL9_SCALE,
	2927	SLIDER_BLOOM_LVL10_SCALE,
	2928	SLIDER_NTSC_ENABLE,
	2929	SLIDER_NTSC_JITTER,
	2930	SLIDER_NTSC_A_VALUE,
	2931	SLIDER_NTSC_B_VALUE,
	2932	SLIDER_NTSC_P_VALUE,
	2933	SLIDER_NTSC_O_VALUE,
	2934	SLIDER_NTSC_CC_VALUE,
	2935	SLIDER_NTSC_N_VALUE,
	2936	SLIDER_NTSC_Y_VALUE,
	2937	SLIDER_NTSC_I_VALUE,
	2938	SLIDER_NTSC_Q_VALUE,
	2939	SLIDER_NTSC_SCAN_TIME
	2940	};
	2941
2848	2942	shaders::slider_desc shaders::s_sliders[] =
2849	2943	{
2850		{ "Vector Length Attenuation",           0,    50,   100, 1, 2, slider_vector_attenuation },
2851		{ "Vector Attenuation Length Limit",     1,   500,  1000, 1, 2, slider_vector_length_max },
2852		{ "Shadow Mask Tile Mode",               0,     0,     1, 1, 7, slider_shadow_mask_tile_mode },
2853		{ "Shadow Mask Darkness",                0,     0,   100, 1, 7, slider_shadow_mask_alpha },
2854		{ "Shadow Mask X Count",                 1,     1,  1024, 1, 7, slider_shadow_mask_x_count },
2855		{ "Shadow Mask Y Count",                 1,     1,  1024, 1, 7, slider_shadow_mask_y_count },
2856		{ "Shadow Mask Pixel Count X",           1,     1,    64, 1, 7, slider_shadow_mask_usize },
2857		{ "Shadow Mask Pixel Count Y",           1,     1,    64, 1, 7, slider_shadow_mask_vsize },
2858		{ "Shadow Mask Offset X",             -100,     0,   100, 1, 7, slider_shadow_mask_uoffset },
2859		{ "Shadow Mask Offset Y",             -100,     0,   100, 1, 7, slider_shadow_mask_voffset },
2860		{ "Screen Curvature",                    0,     0,   100, 1, 7, slider_curvature },
2861		{ "Screen Round Corner",                 0,     0,   100, 1, 7, slider_round_corner },
2862		{ "Screen Smooth Border",                0,     0,   100, 1, 7, slider_smooth_border },
2863		{ "Screen Reflection",                   0,     0,   100, 1, 7, slider_reflection },
2864		{ "Image Vignetting",                    0,     0,   100, 1, 7, slider_vignetting },
2865		{ "Scanline Darkness",                   0,     0,   100, 1, 5, slider_scanline_alpha },
2866		{ "Scanline Screen Height",              1,    20,    80, 1, 5, slider_scanline_scale },
2867		{ "Scanline Indiv. Height",              1,    20,    80, 1, 5, slider_scanline_height },
2868		{ "Scanline Brightness",                 0,    20,    40, 1, 5, slider_scanline_bright_scale },
2869		{ "Scanline Brightness Overdrive",       0,     0,    20, 1, 5, slider_scanline_bright_offset },
2870		{ "Scanline Jitter",                     0,     0,   100, 1, 5, slider_scanline_jitter },
2871		{ "Hum Bar Darkness",                    0,     0,   100, 1, 5, slider_hum_bar_alpha },
2872		{ "Defocus X",                           0,     0,   100, 1, 7, slider_defocus_x },
2873		{ "Defocus Y",                           0,     0,   100, 1, 7, slider_defocus_y },
2874		{ "Red Position Offset X",            -100,     0,   100, 1, 7, slider_red_converge_x },
2875		{ "Red Position Offset Y",            -100,     0,   100, 1, 7, slider_red_converge_y },
2876		{ "Green Position Offset X",          -100,     0,   100, 1, 7, slider_green_converge_x },
2877		{ "Green Position Offset Y",          -100,     0,   100, 1, 7, slider_green_converge_y },
2878		{ "Blue Position Offset X",           -100,     0,   100, 1, 7, slider_blue_converge_x },
2879		{ "Blue Position Offset Y",           -100,     0,   100, 1, 7, slider_blue_converge_y },
2880		{ "Red Convergence X",                -100,     0,   100, 1, 7, slider_red_radial_converge_x },
2881		{ "Red Convergence Y",                -100,     0,   100, 1, 7, slider_red_radial_converge_y },
2882		{ "Green Convergence X",              -100,     0,   100, 1, 7, slider_green_radial_converge_x },
2883		{ "Green Convergence Y",              -100,     0,   100, 1, 7, slider_green_radial_converge_y },
2884		{ "Blue Convergence X",               -100,     0,   100, 1, 7, slider_blue_radial_converge_x },
2885		{ "Blue Convergence Y",               -100,     0,   100, 1, 7, slider_blue_radial_converge_y },
2886		{ "Red Output from Red Input",        -400,     0,   400, 5, 7, slider_red_from_r },
2887		{ "Red Output from Green Input",      -400,     0,   400, 5, 7, slider_red_from_g },
2888		{ "Red Output from Blue Input",       -400,     0,   400, 5, 7, slider_red_from_b },
2889		{ "Green Output from Red Input",      -400,     0,   400, 5, 7, slider_green_from_r },
2890		{ "Green Output from Green Input",    -400,     0,   400, 5, 7, slider_green_from_g },
2891		{ "Green Output from Blue Input",     -400,     0,   400, 5, 7, slider_green_from_b },
2892		{ "Blue Output from Red Input",       -400,     0,   400, 5, 7, slider_blue_from_r },
2893		{ "Blue Output from Green Input",     -400,     0,   400, 5, 7, slider_blue_from_g },
2894		{ "Blue Output from Blue Input",      -400,     0,   400, 5, 7, slider_blue_from_b },
2895		{ "Saturation",                          0,   100,   400, 1, 7, slider_saturation },
2896		{ "Red DC Offset",                    -100,     0,   100, 1, 7, slider_red_offset },
2897		{ "Green DC Offset",                  -100,     0,   100, 1, 7, slider_green_offset },
2898		{ "Blue DC Offset",                   -100,     0,   100, 1, 7, slider_blue_offset },
2899		{ "Red Scale",                        -200,   100,   200, 1, 7, slider_red_scale },
2900		{ "Green Scale",                      -200,   100,   200, 1, 7, slider_green_scale },
2901		{ "Blue Scale",                       -200,   100,   200, 1, 7, slider_blue_scale },
2902		{ "Red Gamma",                         -80,     0,    80, 1, 7, slider_red_power },
2903		{ "Green Gamma",                       -80,     0,    80, 1, 7, slider_green_power },
2904		{ "Blue Gamma",                        -80,     0,    80, 1, 7, slider_blue_power },
2905		{ "Red Floor",                           0,     0,   100, 1, 7, slider_red_floor },
2906		{ "Green Floor",                         0,     0,   100, 1, 7, slider_green_floor },
2907		{ "Blue Floor",                          0,     0,   100, 1, 7, slider_blue_floor },
2908		{ "Red Phosphor Life",                   0,     0,   100, 1, 7, slider_red_phosphor_life },
2909		{ "Green Phosphor Life",                 0,     0,   100, 1, 7, slider_green_phosphor_life },
2910		{ "Blue Phosphor Life",                  0,     0,   100, 1, 7, slider_blue_phosphor_life },
2911		{ "Bloom Blend Mode",                    0,     0,     1, 1, 7, slider_bloom_blend_mode },
2912		{ "Bloom Scale",                         0,     0,  2000, 5, 7, slider_bloom_scale },
2913		{ "Bloom Red Overdrive",                 0,     0,  2000, 5, 7, slider_bloom_red_overdrive },
2914		{ "Bloom Green Overdrive",               0,     0,  2000, 5, 7, slider_bloom_green_overdrive },
2915		{ "Bloom Blue Overdrive",                0,     0,  2000, 5, 7, slider_bloom_blue_overdrive },
2916		{ "Bloom Level 0 Scale",                 0,   100,   100, 1, 7, slider_bloom_lvl0_scale },
2917		{ "Bloom Level 1 Scale",                 0,     0,   100, 1, 7, slider_bloom_lvl1_scale },
2918		{ "Bloom Level 2 Scale",                 0,     0,   100, 1, 7, slider_bloom_lvl2_scale },
2919		{ "Bloom Level 3 Scale",                 0,     0,   100, 1, 7, slider_bloom_lvl3_scale },
2920		{ "Bloom Level 4 Scale",                 0,     0,   100, 1, 7, slider_bloom_lvl4_scale },
2921		{ "Bloom Level 5 Scale",                 0,     0,   100, 1, 7, slider_bloom_lvl5_scale },
2922		{ "Bloom Level 6 Scale",                 0,     0,   100, 1, 7, slider_bloom_lvl6_scale },
2923		{ "Bloom Level 7 Scale",                 0,     0,   100, 1, 7, slider_bloom_lvl7_scale },
2924		{ "Bloom Level 8 Scale",                 0,     0,   100, 1, 7, slider_bloom_lvl8_scale },
2925		{ "Bloom Level 9 Scale",                 0,     0,   100, 1, 7, slider_bloom_lvl9_scale },
2926		{ "Bloom Level 10 Scale",                0,     0,   100, 1, 7, slider_bloom_lvl10_scale },
2927		{ "NTSC processing",                     0,     0,     1, 1, 5, slider_ntsc_enable },
2928		{ "Signal Jitter",                       0,     0,   100, 1, 5, slider_ntsc_jitter },
2929		{ "A Value",                          -100,    50,   100, 1, 5, slider_ntsc_a_value },
2930		{ "B Value",                          -100,    50,   100, 1, 5, slider_ntsc_b_value },
2931		{ "Incoming Pixel Clock Scaling",     -300,   100,   300, 1, 5, slider_ntsc_p_value },
2932		{ "Outgoing Color Carrier Phase",     -300,     0,   300, 1, 5, slider_ntsc_o_value },
2933		{ "Color Carrier Frequency",             0, 35795, 60000, 5, 5, slider_ntsc_cc_value },
2934		{ "Y Notch",                             0,   100,   600, 5, 5, slider_ntsc_n_value },
2935		{ "Y Frequency",                         0,   600,   600, 5, 5, slider_ntsc_y_value },
2936		{ "I Frequency",                         0,   120,   600, 5, 5, slider_ntsc_i_value },
2937		{ "Q Frequency",                         0,    60,   600, 5, 5, slider_ntsc_q_value },
2938		{ "Scanline Duration",                   0,  5260, 10000, 1, 5, slider_ntsc_scan_time },
2939		// { "Phase Count",                         1,     2,     3, 1, 5, slider_ntsc_phase_count },
2940		{ NULL, 0, 0, 0, 0, 0, NULL },
	2944	{ "Vector Length Attenuation",           0,    50,   100, 1, SLIDER_SCREEN_TYPE_VECTOR, slider_vector_attenuation, SLIDER_VECTOR_ATTENUATION },
	2945	{ "Vector Attenuation Length Limit",     1,   500,  1000, 1, SLIDER_SCREEN_TYPE_VECTOR, slider_vector_length_max, SLIDER_VECTOR_LENGTH_MAX },
	2946	{ "Shadow Mask Tile Mode",               0,     0,     1, 1, SLIDER_SCREEN_TYPE_ANY, slider_shadow_mask_tile_mode, SLIDER_SHADOW_MASK_TILE_MODE },
	2947	{ "Shadow Mask Darkness",                0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_shadow_mask_alpha, SLIDER_SHADOW_MASK_ALPHA },
	2948	{ "Shadow Mask X Count",                 1,     1,  1024, 1, SLIDER_SCREEN_TYPE_ANY, slider_shadow_mask_x_count, SLIDER_SHADOW_MASK_X_COUNT },
	2949	{ "Shadow Mask Y Count",                 1,     1,  1024, 1, SLIDER_SCREEN_TYPE_ANY, slider_shadow_mask_y_count, SLIDER_SHADOW_MASK_Y_COUNT },
	2950	{ "Shadow Mask Pixel Count X",           1,     1,    64, 1, SLIDER_SCREEN_TYPE_ANY, slider_shadow_mask_usize, SLIDER_SHADOW_MASK_U_SIZE },
	2951	{ "Shadow Mask Pixel Count Y",           1,     1,    64, 1, SLIDER_SCREEN_TYPE_ANY, slider_shadow_mask_vsize, SLIDER_SHADOW_MASK_V_SIZE },
	2952	{ "Shadow Mask Offset X",             -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_shadow_mask_uoffset, SLIDER_SHADOW_MASK_U_OFFSET },
	2953	{ "Shadow Mask Offset Y",             -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_shadow_mask_voffset, SLIDER_SHADOW_MASK_V_OFFSET },
	2954	{ "Screen Curvature",                    0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_curvature, SLIDER_CURVATURE },
	2955	{ "Screen Round Corner",                 0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_round_corner, SLIDER_ROUND_CORNER },
	2956	{ "Screen Smooth Border",                0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_smooth_border, SLIDER_SMOOTH_BORDER },
	2957	{ "Screen Reflection",                   0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_reflection, SLIDER_REFLECTION },
	2958	{ "Image Vignetting",                    0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_vignetting, SLIDER_VIGNETTING },
	2959	{ "Scanline Darkness",                   0,     0,   100, 1, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_scanline_alpha, SLIDER_SCANLINE_ALPHA },
	2960	{ "Scanline Screen Height",              1,    20,    80, 1, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_scanline_scale, SLIDER_SCANLINE_SCALE },
	2961	{ "Scanline Indiv. Height",              1,    20,    80, 1, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_scanline_height, SLIDER_SCANLINE_HEIGHT },
	2962	{ "Scanline Brightness",                 0,    20,    40, 1, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_scanline_bright_scale, SLIDER_SCANLINE_BRIGHT_SCALE },
	2963	{ "Scanline Brightness Overdrive",       0,     0,    20, 1, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_scanline_bright_offset, SLIDER_SCANLINE_BRIGHT_OFFSET },
	2964	{ "Scanline Jitter",                     0,     0,   100, 1, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_scanline_jitter, SLIDER_SCANLINE_JITTER },
	2965	{ "Hum Bar Darkness",                    0,     0,   100, 1, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_hum_bar_alpha, SLIDER_HUM_BAR_ALPHA },
	2966	{ "Defocus X",                           0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_defocus_x, SLIDER_DEFOCUS_X },
	2967	{ "Defocus Y",                           0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_defocus_y, SLIDER_DEFOCUS_Y },
	2968	{ "Red Position Offset X",            -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_red_converge_x, SLIDER_RED_CONVERGE_X },
	2969	{ "Red Position Offset Y",            -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_red_converge_y, SLIDER_RED_CONVERGE_Y },
	2970	{ "Green Position Offset X",          -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_green_converge_x, SLIDER_GREEN_CONVERGE_X },
	2971	{ "Green Position Offset Y",          -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_green_converge_y, SLIDER_GREEN_CONVERGE_Y },
	2972	{ "Blue Position Offset X",           -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_blue_converge_x, SLIDER_BLUE_CONVERGE_X },
	2973	{ "Blue Position Offset Y",           -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_blue_converge_y, SLIDER_BLUE_CONVERGE_Y },
	2974	{ "Red Convergence X",                -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_red_radial_converge_x, SLIDER_RED_RADIAL_CONVERGE_X },
	2975	{ "Red Convergence Y",                -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_red_radial_converge_y, SLIDER_RED_RADIAL_CONVERGE_Y },
	2976	{ "Green Convergence X",              -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_green_radial_converge_x, SLIDER_GREEN_RADIAL_CONVERGE_X },
	2977	{ "Green Convergence Y",              -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_green_radial_converge_y, SLIDER_GREEN_RADIAL_CONVERGE_Y },
	2978	{ "Blue Convergence X",               -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_blue_radial_converge_x, SLIDER_BLUE_RADIAL_CONVERGE_X },
	2979	{ "Blue Convergence Y",               -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_blue_radial_converge_y, SLIDER_BLUE_RADIAL_CONVERGE_Y },
	2980	{ "Red Output from Red Input",        -400,     0,   400, 5, SLIDER_SCREEN_TYPE_ANY, slider_red_from_r, SLIDER_RED_FROM_R },
	2981	{ "Red Output from Green Input",      -400,     0,   400, 5, SLIDER_SCREEN_TYPE_ANY, slider_red_from_g, SLIDER_RED_FROM_G },
	2982	{ "Red Output from Blue Input",       -400,     0,   400, 5, SLIDER_SCREEN_TYPE_ANY, slider_red_from_b, SLIDER_RED_FROM_B },
	2983	{ "Green Output from Red Input",      -400,     0,   400, 5, SLIDER_SCREEN_TYPE_ANY, slider_green_from_r, SLIDER_GREEN_FROM_R },
	2984	{ "Green Output from Green Input",    -400,     0,   400, 5, SLIDER_SCREEN_TYPE_ANY, slider_green_from_g, SLIDER_GREEN_FROM_G },
	2985	{ "Green Output from Blue Input",     -400,     0,   400, 5, SLIDER_SCREEN_TYPE_ANY, slider_green_from_b, SLIDER_GREEN_FROM_B },
	2986	{ "Blue Output from Red Input",       -400,     0,   400, 5, SLIDER_SCREEN_TYPE_ANY, slider_blue_from_r, SLIDER_BLUE_FROM_R },
	2987	{ "Blue Output from Green Input",     -400,     0,   400, 5, SLIDER_SCREEN_TYPE_ANY, slider_blue_from_g, SLIDER_BLUE_FROM_G },
	2988	{ "Blue Output from Blue Input",      -400,     0,   400, 5, SLIDER_SCREEN_TYPE_ANY, slider_blue_from_b, SLIDER_BLUE_FROM_B },
	2989	{ "Saturation",                          0,   100,   400, 1, SLIDER_SCREEN_TYPE_ANY, slider_saturation, SLIDER_SATURATION },
	2990	{ "Red DC Offset",                    -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_red_offset, SLIDER_RED_OFFSET },
	2991	{ "Green DC Offset",                  -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_green_offset, SLIDER_GREEN_OFFSET },
	2992	{ "Blue DC Offset",                   -100,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_blue_offset, SLIDER_BLUE_OFFSET },
	2993	{ "Red Scale",                        -200,   100,   200, 1, SLIDER_SCREEN_TYPE_ANY, slider_red_scale, SLIDER_RED_SCALE },
	2994	{ "Green Scale",                      -200,   100,   200, 1, SLIDER_SCREEN_TYPE_ANY, slider_green_scale, SLIDER_GREEN_SCALE },
	2995	{ "Blue Scale",                       -200,   100,   200, 1, SLIDER_SCREEN_TYPE_ANY, slider_blue_scale, SLIDER_BLUE_SCALE },
	2996	{ "Red Gamma",                         -80,     0,    80, 1, SLIDER_SCREEN_TYPE_ANY, slider_red_power, SLIDER_RED_POWER },
	2997	{ "Green Gamma",                       -80,     0,    80, 1, SLIDER_SCREEN_TYPE_ANY, slider_green_power, SLIDER_GREEN_POWER },
	2998	{ "Blue Gamma",                        -80,     0,    80, 1, SLIDER_SCREEN_TYPE_ANY, slider_blue_power, SLIDER_BLUE_POWER },
	2999	{ "Red Floor",                           0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_red_floor, SLIDER_RED_FLOOR },
	3000	{ "Green Floor",                         0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_green_floor, SLIDER_GREEN_FLOOR },
	3001	{ "Blue Floor",                          0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_blue_floor, SLIDER_BLUE_FLOOR },
	3002	{ "Red Phosphor Life",                   0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_red_phosphor_life, SLIDER_RED_PHOSPHOR },
	3003	{ "Green Phosphor Life",                 0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_green_phosphor_life, SLIDER_GREEN_PHOSPHOR },
	3004	{ "Blue Phosphor Life",                  0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_blue_phosphor_life, SLIDER_BLUE_PHOSPHOR },
	3005	{ "Bloom Blend Mode",                    0,     0,     1, 1, SLIDER_SCREEN_TYPE_ANY, slider_bloom_blend_mode, SLIDER_BLOOM_BLEND_MODE },
	3006	{ "Bloom Scale",                         0,     0,  2000, 5, SLIDER_SCREEN_TYPE_ANY, slider_bloom_scale, SLIDER_BLOOM_SCALE },
	3007	{ "Bloom Red Overdrive",                 0,     0,  2000, 5, SLIDER_SCREEN_TYPE_ANY, slider_bloom_red_overdrive, SLIDER_BLOOM_RED_OVERDRIVE },
	3008	{ "Bloom Green Overdrive",               0,     0,  2000, 5, SLIDER_SCREEN_TYPE_ANY, slider_bloom_green_overdrive, SLIDER_BLOOM_GREEN_OVERDRIVE },
	3009	{ "Bloom Blue Overdrive",                0,     0,  2000, 5, SLIDER_SCREEN_TYPE_ANY, slider_bloom_blue_overdrive, SLIDER_BLOOM_BLUE_OVERDRIVE },
	3010	{ "Bloom Level 0 Scale",                 0,   100,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_bloom_lvl0_scale, SLIDER_BLOOM_LVL0_SCALE },
	3011	{ "Bloom Level 1 Scale",                 0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_bloom_lvl1_scale, SLIDER_BLOOM_LVL1_SCALE },
	3012	{ "Bloom Level 2 Scale",                 0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_bloom_lvl2_scale, SLIDER_BLOOM_LVL2_SCALE },
	3013	{ "Bloom Level 3 Scale",                 0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_bloom_lvl3_scale, SLIDER_BLOOM_LVL3_SCALE },
	3014	{ "Bloom Level 4 Scale",                 0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_bloom_lvl4_scale, SLIDER_BLOOM_LVL4_SCALE },
	3015	{ "Bloom Level 5 Scale",                 0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_bloom_lvl5_scale, SLIDER_BLOOM_LVL5_SCALE },
	3016	{ "Bloom Level 6 Scale",                 0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_bloom_lvl6_scale, SLIDER_BLOOM_LVL6_SCALE },
	3017	{ "Bloom Level 7 Scale",                 0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_bloom_lvl7_scale, SLIDER_BLOOM_LVL7_SCALE },
	3018	{ "Bloom Level 8 Scale",                 0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_bloom_lvl8_scale, SLIDER_BLOOM_LVL8_SCALE },
	3019	{ "Bloom Level 9 Scale",                 0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_bloom_lvl9_scale, SLIDER_BLOOM_LVL9_SCALE },
	3020	{ "Bloom Level 10 Scale",                0,     0,   100, 1, SLIDER_SCREEN_TYPE_ANY, slider_bloom_lvl10_scale, SLIDER_BLOOM_LVL10_SCALE },
	3021	{ "NTSC processing",                     0,     0,     1, 1, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_ntsc_enable, SLIDER_NTSC_ENABLE },
	3022	{ "Signal Jitter",                       0,     0,   100, 1, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_ntsc_jitter, SLIDER_NTSC_JITTER },
	3023	{ "A Value",                          -100,    50,   100, 1, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_ntsc_a_value, SLIDER_NTSC_A_VALUE },
	3024	{ "B Value",                          -100,    50,   100, 1, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_ntsc_b_value, SLIDER_NTSC_B_VALUE },
	3025	{ "Incoming Pixel Clock Scaling",     -300,   100,   300, 1, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_ntsc_p_value, SLIDER_NTSC_P_VALUE },
	3026	{ "Outgoing Color Carrier Phase",     -300,     0,   300, 1, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_ntsc_o_value, SLIDER_NTSC_O_VALUE },
	3027	{ "Color Carrier Frequency",             0, 35795, 60000, 5, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_ntsc_cc_value, SLIDER_NTSC_CC_VALUE },
	3028	{ "Y Notch",                             0,   100,   600, 5, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_ntsc_n_value, SLIDER_NTSC_N_VALUE },
	3029	{ "Y Frequency",                         0,   600,   600, 5, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_ntsc_y_value, SLIDER_NTSC_Y_VALUE },
	3030	{ "I Frequency",                         0,   120,   600, 5, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_ntsc_i_value, SLIDER_NTSC_I_VALUE },
	3031	{ "Q Frequency",                         0,    60,   600, 5, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_ntsc_q_value, SLIDER_NTSC_Q_VALUE },
	3032	{ "Scanline Duration",                   0,  5260, 10000, 1, SLIDER_SCREEN_TYPE_LCD_OR_RASTER, slider_ntsc_scan_time, SLIDER_NTSC_SCAN_TIME },
	3033	{ NULL, 0, 0, 0, 0, 0, NULL, -1 },
2941	3034	};
2942	3035
2943	3036
r253579	r253580
2965	3058	(screen_type == SCREEN_TYPE_RASTER && (slider->screen_type & SLIDER_SCREEN_TYPE_RASTER) == SLIDER_SCREEN_TYPE_RASTER) ||
2966	3059	(screen_type == SCREEN_TYPE_LCD    && (slider->screen_type & SLIDER_SCREEN_TYPE_LCD)    == SLIDER_SCREEN_TYPE_LCD))
2967	3060	{
2968		*tailptr = slider_alloc(*machine, slider->name, slider->minval, slider->defval, slider->maxval, slider->step, slider->adjustor, (void*)options);
	3061	*tailptr = slider_alloc(*machine, slider->id, slider->name, slider->minval, slider->defval, slider->maxval, slider->step, slider->adjustor, (void*)options);
2969	3062	tailptr = &(*tailptr)->next;
2970	3063	}
2971	3064	}

trunk/src/osd/modules/render/d3d/d3dhlsl.h

r253579	r253580
320	320	SLIDER_SCREEN_TYPE_NONE = 0,
321	321	SLIDER_SCREEN_TYPE_RASTER = 1,
322	322	SLIDER_SCREEN_TYPE_VECTOR = 2,
323		SLIDER_SCREEN_TYPE_LCD = 4
	323	SLIDER_SCREEN_TYPE_LCD = 4,
	324	SLIDER_SCREEN_TYPE_LCD_OR_RASTER = SLIDER_SCREEN_TYPE_RASTER | SLIDER_SCREEN_TYPE_LCD,
	325	SLIDER_SCREEN_TYPE_ANY = SLIDER_SCREEN_TYPE_RASTER | SLIDER_SCREEN_TYPE_VECTOR | SLIDER_SCREEN_TYPE_LCD
324	326	};
325	327
326	328	struct slider_desc
r253579	r253580
332	334	int                 step;
333	335	int                 screen_type;
334	336	INT32(*adjustor)(running_machine &, void *, std::string *, INT32);
	337	int               id;
335	338	};
336	339
337	340	private:

trunk/src/osd/modules/render/draw13.cpp

r253579	r253580
84	84	* prohibit fullscreen toggling. It is than not possible
85	85	* to toggle from fullscreen to window mode.
86	86	*/
87		expand_copy_info(blit_info_default);
	87	expand_copy_info(s_blit_info_default);
88	88	s_blit_info_initialized = true;
89	89	}
90	90	}
r253579	r253580
180	180	{ -1 },
181	181	};
182	182
183		copy_info_t* renderer_sdl::s_blit_info[SDL_TEXFORMAT_LAST+1] = { NULL };
	183	copy_info_t* renderer_sdl1::s_blit_info[SDL_TEXFORMAT_LAST+1] = { NULL };
184	184	bool renderer_sdl1::s_blit_info_initialized = false;
185	185
186	186	//============================================================
r253579	r253580
216	216	return SDL_BLENDMODE_NONE;
217	217	}
218	218
219		void renderer_sdl1::set_coloralphamode(SDL_Texture *texture_id, const render_color *color)
	219	void texture_info::set_coloralphamode(SDL_Texture *texture_id, const render_color *color)
220	220	{
221	221	UINT32 sr = (UINT32)(255.0f * color->r);
222	222	UINT32 sg = (UINT32)(255.0f * color->g);
r253579	r253580
333	333	//  drawsdl_init
334	334	//============================================================
335	335
336		static void add_list(copy_info_t **head, copy_info_t *element, Uint32 bm)
	336	void renderer_sdl1::add_list(copy_info_t **head, const copy_info_t *element, Uint32 bm)
337	337	{
338	338	copy_info_t *newci = global_alloc(copy_info_t);
339	339	*newci = *element;
r253579	r253580
343	343	*head = newci;
344	344	}
345	345
346		static void expand_copy_info(copy_info_t *list)
	346	void renderer_sdl1::expand_copy_info(const copy_info_t *list)
347	347	{
348		copy_info_t   *bi;
349
350		for (bi = list; bi->src_fmt != -1; bi++)
	348	for (const copy_info_t *bi = list; bi->src_fmt != -1; bi++)
351	349	{
352	350	if (bi->bm_mask == BM_ALL)
353	351	{
r253579	r253580
357	355	add_list(&s_blit_info[bi->src_fmt], bi, SDL_BLENDMODE_BLEND);
358	356	}
359	357	else
	358	{
360	359	add_list(&s_blit_info[bi->src_fmt], bi, bi->bm_mask);
	360	}
361	361	}
362	362	}
363	363
364		static osd_renderer *drawsdl2_create(osd_window *window)
365		{
366		return global_alloc(renderer_sdl1(window, osd_renderer::FLAG_NONE));
367		}
368
369	364	// FIXME: machine only used to access options.
370		int renderer_sdl1::init(running_machine &machine)
	365	bool renderer_sdl1::init(running_machine &machine)
371	366	{
372	367	osd_printf_verbose("Using SDL native texturing driver (SDL 2.0+)\n");
373	368
r253579	r253580
386	381	else
387	382	osd_printf_verbose("Loaded opengl shared library: %s\n", stemp ? stemp : "<default>");
388	383
389		return 0;
	384	return false;
390	385	}
391	386
392	387
r253579	r253580
615	610
616	611	copy_info_t *texture_info::compute_size_type()
617	612	{
618		copy_info_t *bi;
619	613	copy_info_t *result = NULL;
620	614	int maxperf = 0;
621	615
622		for (bi = blit_info[m_format]; bi != NULL; bi = bi->next)
	616	for (copy_info_t *bi = renderer_sdl1::s_blit_info[m_format]; bi != NULL; bi = bi->next)
623	617	{
624	618	if ((m_is_rotated == bi->blitter->m_is_rot)
625	619	&& (m_sdl_blendmode == bi->bm_mask))
r253579	r253580
637	631	}
638	632	}
639	633	}
	634
640	635	if (result)
641	636	return result;
	637
642	638	/* try last resort handlers */
643		for (bi = blit_info[m_format]; bi != NULL; bi = bi->next)
	639	for (copy_info_t *bi = renderer_sdl1::s_blit_info[m_format]; bi != NULL; bi = bi->next)
644	640	{
645	641	if ((m_is_rotated == bi->blitter->m_is_rot)
646	642	&& (m_sdl_blendmode == bi->bm_mask))
r253579	r253580
906	902	//  texture_update
907	903	//============================================================
908	904
909		texture_info * renderer_sdl3::texture_update(const render_primitive &prim)
	905	texture_info * renderer_sdl1::texture_update(const render_primitive &prim)
910	906	{
911	907	quad_setup_data setup;
912	908	texture_info *texture;
r253579	r253580
936	932	return texture;
937	933	}
938	934
939		render_primitive_list *renderer_sdl13::get_primitives()
	935	render_primitive_list *renderer_sdl1::get_primitives()
940	936	{
941	937	osd_dim nd = window().blit_surface_size();
942	938	if (nd != m_blit_dim)

trunk/src/osd/modules/render/draw13.h

r253579	r253580
88	88	bool is_pixels_owned() const;
89	89
90	90	private:
	91	void set_coloralphamode(SDL_Texture *texture_id, const render_color *color);
	92
91	93	Uint32              m_sdl_access;
92	94	renderer_sdl1 *     m_renderer;
93	95	render_texinfo      m_texinfo;            // copy of the texture info
r253579	r253580
176	178	}
177	179
178	180	virtual int create() override;
179		virtual int init(running_machine &machine) override;
	181	static bool init(running_machine &machine);
180	182	virtual int draw(const int update) override;
181	183	virtual int xy_to_render_target(const int x, const int y, int *xt, int *yt) override;
182	184	virtual render_primitive_list *get_primitives() override;
r253579	r253580
184	186
185	187	SDL_Renderer *  m_sdl_renderer;
186	188
	189	static copy_info_t* s_blit_info[SDL_TEXFORMAT_LAST+1];
	190
187	191	private:
	192	void expand_copy_info(const copy_info_t *list);
	193	void add_list(copy_info_t **head, const copy_info_t *element, Uint32 bm);
	194
188	195	void render_quad(texture_info *texture, const render_primitive *prim, const int x, const int y);
189		void set_coloralphamode(SDL_Texture *texture_id, const render_color *color);
190	196
191	197	texture_info *texture_find(const render_primitive &prim, const quad_setup_data &setup);
192	198	texture_info *texture_update(const render_primitive &prim);
r253579	r253580
216	222	INT64           m_last_blit_time;
217	223	INT64           m_last_blit_pixels;
218	224
219		static copy_info_t* s_blit_info[SDL_TEXFORMAT_LAST+1];
220	225	static bool s_blit_info_initialized;
221	226	static const copy_info_t s_blit_info_default[];
222	227	};

trunk/src/osd/modules/render/drawbgfx.h

r253579	r253580
31	31
32	32	virtual int create() override;
33	33	virtual slider_state* get_slider_list() override;
34		virtual int init(running_machine &machine) override { return 0; }
	34	static bool init(running_machine &machine) { return false; }
35	35	virtual int draw(const int update) override;
36	36	#ifdef OSD_SDL
37	37	virtual int xy_to_render_target(const int x, const int y, int *xt, int *yt) override;

trunk/src/osd/modules/render/drawd3d.cpp

r253579	r253580
219	219	//  drawnone_create
220	220	//============================================================
221	221
222		int renderer_d3d9::init(running_machine &machine)
	222	bool renderer_d3d9::init(running_machine &machine)
223	223	{
224	224	// Use Direct3D9
225	225	d3dintf = drawd3d9_init();
r253579	r253580
228	228	if (d3dintf == nullptr)
229	229	{
230	230	osd_printf_error("Unable to initialize Direct3D.\n");
231		return 1;
	231	return true;
232	232	}
233	233
234		return 0;
	234	return false;
235	235	}
236	236
237	237
r253579	r253580
576	576	{
577	577	// configure the adapter for the mode we want
578	578	if (config_adapter_mode())
	579	{
579	580	return false;
	581	}
580	582
581	583	// create the device immediately for the full screen case (defer for window mode)
582	584	if (window().fullscreen() && device_create(window().m_focus_hwnd))
	585	{
583	586	return false;
	587	}
584	588
585	589	return true;
586	590	}
r253579	r253580
870	874
871	875	m_shaders = (shaders*)global_alloc_clear<shaders>();
872	876	m_shaders->init(d3dintf, &window().machine(), this);
	877	m_sliders_dirty = true;
873	878
874	879	int failed = m_shaders->create_resources(false);
875	880	if (failed)

trunk/src/osd/modules/render/drawd3d.h

r253579	r253580
43	43
44	44	virtual int create() override;
45	45	virtual slider_state* get_slider_list() override;
46		virtual int init(running_machine &machine) override;
	46	static bool init(running_machine &machine);
47	47	virtual render_primitive_list *get_primitives() override;
48	48	virtual int draw(const int update) override;
49	49	virtual void save() override;

trunk/src/osd/modules/render/drawgdi.h

r253579	r253580
38	38	virtual ~renderer_gdi();
39	39
40	40	virtual int create() override;
41		virtual int init(running_machine &machine) override { return 0; }
	41	static bool init(running_machine &machine) { return false; }
42	42	virtual render_primitive_list *get_primitives() override;
43	43	virtual int draw(const int update) override;
44	44	virtual void save() override {};

trunk/src/osd/modules/render/drawnone.h

r253579	r253580
23	23	virtual ~renderer_none() { }
24	24
25	25	virtual int create() override { return 0; }
26		virtual int init(running_machine &machine) override { return 0; }
	26	static bool init(running_machine &machine) { return false; }
27	27	virtual render_primitive_list *get_primitives() override;
28	28	virtual int draw(const int update) override { return 0; }
29	29	virtual void save() override { }

trunk/src/osd/modules/render/drawogl.cpp

r253579	r253580
277	277	bool renderer_ogl::s_shown_video_info = false;
278	278	bool renderer_ogl::s_dll_loaded = false;
279	279
280		int renderer_ogl::init(running_machine &machine)
	280	bool renderer_ogl::init(running_machine &machine)
281	281	{
282	282	s_dll_loaded = false;
283	283
r253579	r253580
288	288	osd_printf_verbose("Using SDL multi-window OpenGL driver (SDL 2.0+)\n");
289	289	#endif
290	290
291		return 0;
	291	return false;
292	292	}
293	293
294	294	//============================================================

trunk/src/osd/modules/render/drawogl.h

r253579	r253580
131	131	virtual ~renderer_ogl();
132	132
133	133	virtual int create() override;
134		virtual int init(running_machine &machine) override;
	134	static bool init(running_machine &machine);
135	135	virtual int draw(const int update) override;
136	136
137	137	#ifndef OSD_WINDOWS
r253579	r253580
165	165
166	166	void destroy_all_textures();
167	167
168		void load_gl_lib(running_machine &machine);
	168	static void load_gl_lib(running_machine &machine);
169	169	void loadGLExtensions();
170	170	void initialize_gl();
171	171	void set_blendmode(int blendmode);

trunk/src/osd/modules/render/drawsdl.cpp

r253579	r253580
44	44	//  PROTOTYPES
45	45	//============================================================
46	46
47		// core functions
48		static void drawsdl_exit(void);
49
50	47	// YUV overlays
51	48
52	49	static void yuv_RGB_to_YV12(const UINT16 *bitmap, UINT8 *ptr, const int pitch, \
r253579	r253580
93	90	//  drawsdl_init
94	91	//============================================================
95	92
96		int renderer_sdl2::init(running_machine &machine)
	93	bool renderer_sdl2::init(running_machine &machine)
97	94	{
98	95	osd_printf_verbose("Using SDL multi-window soft driver (SDL 2.0+)\n");
99		return 0;
	96	return false;
100	97	}
101	98
102	99	//============================================================
r253579	r253580
154	151	//  drawsdl_show_info
155	152	//============================================================
156	153
157		void renderer_sdl::show_info(struct SDL_RendererInfo *render_info)
	154	void renderer_sdl2::show_info(struct SDL_RendererInfo *render_info)
158	155	{
159	156	#define RF_ENTRY(x) {x, #x }
160	157	static struct

trunk/src/osd/modules/render/drawsdl.h

r253579	r253580
36	36	}
37	37	virtual ~renderer_sdl2();
38	38
39		/* virtual */ int create() override;
40		/* virtual */ int init(running_machine &machine) override;
41		/* virtual */ int draw(const int update) override;
42		/* virtual */ int xy_to_render_target(const int x, const int y, int *xt, int *yt) override;
	39	virtual int create() override;
	40	virtual int draw(const int update) override;
	41	virtual int xy_to_render_target(const int x, const int y, int *xt, int *yt) override;
43	42	virtual render_primitive_list *get_primitives() override;
44	43
	44	static bool init(running_machine &machine);
	45
45	46	private:
46	47	void show_info(struct SDL_RendererInfo *render_info);
47	48

trunk/src/osd/sdl/video.cpp

r253579	r253580
83	83	get_resolution(options().resolution(), options().resolution(index), &conf, TRUE);
84	84
85	85	// create window ...
86		sdl_window_info *win = global_alloc(sdl_window_info(machine(), index, sdl_monitor_info::pick_monitor(options(), index), &conf));
	86	sdl_window_info *win = global_alloc(sdl_window_info(machine(), index, osd_monitor_info::pick_monitor(reinterpret_cast<osd_options &>(options()), index), &conf));
87	87
88	88	if (win->window_init())
89	89	return false;
r253579	r253580
229	229	//  pick_monitor
230	230	//============================================================
231	231
232		osd_monitor_info *osd_monitor_info::pick_monitor(sdl_options &options, int index)
	232	osd_monitor_info *osd_monitor_info::pick_monitor(osd_options &generic_options, int index)
233	233	{
	234	sdl_options &options = reinterpret_cast<sdl_options &>(generic_options);
234	235	osd_monitor_info *monitor;
235	236	const char *scrname, *scrname2;
236	237	int moncount = 0;

trunk/src/osd/sdl/video.h

r253579	r253580
12	12	#define __SDLVIDEO__
13	13
14	14	#include "osdsdl.h"
	15	#include "modules/osdwindow.h"
15	16
16	17	//============================================================
17	18	//  CONSTANTS

trunk/src/osd/sdl/window.cpp

r253579	r253580
36	36	#include "window.h"
37	37	#include "input.h"
38	38	#include "osdsdl.h"
	39	#include "modules/render/drawbgfx.h"
	40	#include "modules/render/drawsdl.h"
	41	#include "modules/render/draw13.h"
	42	#if (USE_OPENGL)
	43	#include "modules/render/drawogl.h"
	44	#endif
39	45
40	46	//============================================================
41	47	//  PARAMETERS
r253579	r253580
221	227	}
222	228
223	229	// initialize the drawers
224		if (m_renderer->init(machine()))
225		video_config.mode = VIDEO_MODE_SOFT;
226
	230	if (video_config.mode == VIDEO_MODE_BGFX)
	231	{
	232	if (renderer_bgfx::init(machine()))
	233	{
	234	#if (USE_OPENGL)
	235	video_config.mode = VIDEO_MODE_OPENGL;
	236	}
	237	}
	238	if (video_config.mode == VIDEO_MODE_OPENGL)
	239	{
	240	if (renderer_ogl::init(machine()))
	241	{
	242	video_config.mode = VIDEO_MODE_SOFT;
	243	#else
	244	video_config.mode = VIDEO_MODE_SOFT;
	245	#endif
	246	}
	247	}
	248	if (video_config.mode == VIDEO_MODE_SDL2ACCEL)
	249	{
	250	if (renderer_sdl2::init(machine()))
	251	{
	252	video_config.mode = VIDEO_MODE_SOFT;
	253	}
	254	}
227	255	if (video_config.mode == VIDEO_MODE_SOFT)
228	256	{
229		if (m_renderer->init(machine()))
	257	if (renderer_sdl1::init(machine()))
	258	{
230	259	return false;
	260	}
231	261	}
232	262
233	263	/* We may want to set a number of the hints SDL2 provides.
r253579	r253580
327	357	sdlwindow_sync();
328	358	}
329	359
330		// kill the drawers
331		delete render_module;
332
333	360	execute_async_wait(&sdlwindow_exit_wt, wp_dummy);
334	361
335	362	if (multithreading_enabled)
r253579	r253580
514	541	window->m_windowed_dim = window->get_size();
515	542	}
516	543
517		global_free(window->m_renderer);
	544	delete window->m_renderer;
518	545	window->m_renderer = nullptr;
519	546
520	547	bool is_osx = false;
r253579	r253580
531	558	SDL_DestroyWindow(window->sdl_window());
532	559	sdlinput_release_keys();
533	560
534		osd_renderer *renderer = osd_renderer::make_for_type(video_config.mode, reinterpret_cast<osd_window *>(this));
535		renderer->init(window->machine());
536		window->set_renderer(renderer);
	561	window->set_renderer(osd_renderer::make_for_type(video_config.mode, reinterpret_cast<osd_window *>(window)));
537	562
538	563	// toggle the window mode
539	564	window->set_fullscreen(!window->fullscreen());
r253579	r253580
659	684	*last_window_ptr = this;
660	685	last_window_ptr = &this->m_next;
661	686
662		osd_renderer* renderer =
663		set_renderer(draw.create(this));
	687	set_renderer(osd_renderer::make_for_type(video_config.mode, reinterpret_cast<osd_window *>(this)));
664	688
665	689	// create an event that we can use to skip blitting
666	690	m_rendered_event = osd_event_alloc(FALSE, TRUE);

trunk/src/osd/windows/video.cpp

r253579	r253580
83	83	win_window_info::create(machine(), index, osd_monitor_info::pick_monitor(options, index), &windows[index]);
84	84	}
85	85
86		m_sliders = nullptr;
87		slider_state *curr = m_sliders;
88		for (win_window_info *info = win_window_list; info != nullptr; info = info->m_next)
89		{
90		slider_state *window_sliders = info->m_renderer->get_slider_list();
91		if (window_sliders != nullptr)
92		{
93		if (m_sliders == nullptr)
94		{
95		m_sliders = curr = window_sliders;
96		}
97		else
98		{
99		while (curr->next != nullptr)
100		{
101		curr = curr->next;
102		}
103		curr->next = window_sliders;
104		}
105		}
106		}
107
108	86	if (video_config.mode != VIDEO_MODE_NONE)
109	87	SetForegroundWindow(win_window_list->m_hwnd);
110	88
r253579	r253580
215	193	// ping the watchdog on each update
216	194	winmain_watchdog_ping();
217	195
	196	update_slider_list();
	197
218	198	// if we're not skipping this redraw, update all windows
219	199	if (!skip_redraw)
220	200	{

trunk/src/osd/windows/window.cpp

r253579	r253580
28	28
29	29	#include "winutil.h"
30	30
	31	#include "modules/render/drawbgfx.h"
	32	#include "modules/render/drawnone.h"
	33	#include "modules/render/drawd3d.h"
	34	#include "modules/render/drawgdi.h"
	35	#if (USE_OPENGL)
	36	#include "modules/render/drawogl.h"
	37	#endif
	38
31	39	//============================================================
32	40	//  PARAMETERS
33	41	//============================================================
r253579	r253580
196	204	window_threadid = main_threadid;
197	205	}
198	206
	207	const int fallbacks[VIDEO_MODE_COUNT] = {
	208	-1,               // NONE -> no fallback
	209	VIDEO_MODE_NONE,   // GDI -> NONE
	210	VIDEO_MODE_D3D,      // BGFX -> D3D
	211	#if (USE_OPENGL)
	212	VIDEO_MODE_GDI,      // OPENGL -> GDI
	213	#endif
	214	-1,               // No SDL2ACCEL on Windows OSD
	215	#if (USE_OPENGL)
	216	VIDEO_MODE_OPENGL,   // D3D -> OPENGL
	217	#else
	218	VIDEO_MODE_GDI,      // D3D -> GDI
	219	#endif
	220	-1               // No SOFT on Windows OSD
	221	};
	222
	223	int current_mode = video_config.mode;
	224	while (current_mode != VIDEO_MODE_NONE)
	225	{
	226	bool error = false;
	227	switch(current_mode)
	228	{
	229	case VIDEO_MODE_NONE:
	230	error = renderer_none::init(machine());
	231	break;
	232	case VIDEO_MODE_GDI:
	233	error = renderer_gdi::init(machine());
	234	break;
	235	case VIDEO_MODE_BGFX:
	236	error = renderer_bgfx::init(machine());
	237	break;
	238	#if (USE_OPENGL)
	239	case VIDEO_MODE_OPENGL:
	240	error = renderer_ogl::init(machine());
	241	break;
	242	#endif
	243	case VIDEO_MODE_SDL2ACCEL:
	244	fatalerror("SDL2-Accel renderer unavailable on Windows OSD.");
	245	break;
	246	case VIDEO_MODE_D3D:
	247	error = renderer_d3d9::init(machine());
	248	break;
	249	case VIDEO_MODE_SOFT:
	250	fatalerror("SDL1 renderer unavailable on Windows OSD.");
	251	break;
	252	default:
	253	fatalerror("Unknown video mode.");
	254	break;
	255	}
	256	if (error)
	257	{
	258	current_mode = fallbacks[current_mode];
	259	}
	260	else
	261	{
	262	break;
	263	}
	264	}
	265	video_config.mode = current_mode;
	266
199	267	// set up the window list
200	268	last_window_ptr = &win_window_list;
201	269
202	270	return true;
203	271	}
204	272
	273	void windows_osd_interface::update_slider_list()
	274	{
	275	for (win_window_info *window = win_window_list; window != nullptr; window = window->m_next)
	276	{
	277	if (window->m_renderer->sliders_dirty())
	278	{
	279	build_slider_list();
	280	return;
	281	}
	282	}
	283	}
205	284
	285	void windows_osd_interface::build_slider_list()
	286	{
	287	m_sliders = nullptr;
	288	slider_state *curr = m_sliders;
	289	for (win_window_info *info = win_window_list; info != nullptr; info = info->m_next)
	290	{
	291	slider_state *window_sliders = info->m_renderer->get_slider_list();
	292	if (window_sliders != nullptr)
	293	{
	294	if (m_sliders == nullptr)
	295	{
	296	m_sliders = curr = window_sliders;
	297	}
	298	else
	299	{
	300	while (curr->next != nullptr)
	301	{
	302	curr = curr->next;
	303	}
	304	curr->next = window_sliders;
	305	}
	306	}
	307	}
	308	}
206	309
207	310	//============================================================
208	311	//  winwindow_exit
r253579	r253580
300	403
301	404	static BOOL is_mame_window(HWND hwnd)
302	405	{
303		win_window_info *window;
304
305		for (window = win_window_list; window != nullptr; window = window->m_next)
	406	for (win_window_info *window = win_window_list; window != nullptr; window = window->m_next)
306	407	if (window->m_hwnd == hwnd)
307	408	return TRUE;
308	409
r253579	r253580
609	710
610	711	// allocate a new window object
611	712	win_window_info *window = global_alloc(win_window_info(machine));
612		//printf("%d, %d\n", config->width, config->height);
613	713	window->m_win_config = *config;
614	714	window->m_monitor = monitor;
615	715	window->m_fullscreen = !video_config.windowed;
616	716	window->m_index = index;
617		window->m_renderer = reinterpret_cast<osd_renderer *>(osd_renderer::make_for_type(video_config.mode, reinterpret_cast<osd_window *>(window)));
618		window->m_renderer->init(machine);
619	717
620	718	// set main window
621	719	if (index > 0)
r253579	r253580
1019	1117	return rect_height(&temprect) - 100;
1020	1118	}
1021	1119
1022
1023
1024	1120	//============================================================
1025	1121	//  thread_entry
1026	1122	//  (window thread)
r253579	r253580
1185	1281	if (!m_fullscreen || m_fullscreen_safe)
1186	1282	{
1187	1283	// finish off by trying to initialize DirectX; if we fail, ignore it
	1284	if (m_renderer != nullptr)
	1285	{
	1286	global_free(m_renderer);
	1287	}
	1288	m_renderer = osd_renderer::make_for_type(video_config.mode, reinterpret_cast<osd_window *>(this));
1188	1289	if (m_renderer->create())
1189	1290	return 1;
	1291
1190	1292	ShowWindow(m_hwnd, SW_SHOW);
1191	1293	}
1192	1294
r253579	r253580
1892	1994	{
1893	1995	if (video_config.mode != VIDEO_MODE_NONE)
1894	1996	ShowWindow(m_hwnd, SW_SHOW);
1895		osd_renderer *renderer = reinterpret_cast<osd_renderer *>(osd_renderer::make_for_type(video_config.mode, reinterpret_cast<osd_window *>(this)));
1896		renderer->init(machine());
1897		m_renderer = renderer;
	1997
	1998	if (m_renderer != nullptr)
	1999	{
	2000	delete m_renderer;
	2001	}
	2002	m_renderer = reinterpret_cast<osd_renderer *>(osd_renderer::make_for_type(video_config.mode, reinterpret_cast<osd_window *>(this)));
1898	2003	if (m_renderer->create())
1899	2004	exit(1);
1900	2005	}

trunk/src/osd/windows/winmain.h

r253579	r253580
275	275
276	276	private:
277	277	virtual void osd_exit() override;
278		windows_options &m_options;
279		slider_state *m_sliders;
	278	void build_slider_list();
	279	void update_slider_list();
280	280
	281	windows_options &   m_options;
	282	slider_state *      m_sliders;
	283
281	284	static const int DEFAULT_FONT_HEIGHT = 200;
282	285	};
283	286

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

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team