示例#1
0
void populate_osd_table(GtkWidget* osd_table)
{
	GtkWidget* fontname_label  = left_label("Font:");
	GtkWidget* fontname_file = CreateFileChooser(GTK_FILE_CHOOSER_ACTION_OPEN, "Select a font", "osd_fontname");
	GtkWidget* fontsize_label  = left_label("Size:");
	GtkWidget* fontsize_text = CreateSpinButton(1, 100, "osd_fontsize");
	GtkWidget* transparency_label = left_label("Transparency:");
	GtkWidget* transparency_slide = CreateScale("osd_transparency");
	GtkWidget* log_check = CreateCheckBox("Enable Log", "osd_log_enabled");
	GtkWidget* log_speed_label  = left_label("Speed:");
	GtkWidget* log_speed_text = CreateSpinButton(2, 10, "osd_log_speed");
	GtkWidget* max_messages_label = left_label("Maximum Onscreen Log Messages:");
	GtkWidget* max_messages_spin = CreateSpinButton(1, 20, "osd_max_log_messages");
	GtkWidget* monitor_check = CreateCheckBox("Enable Monitor", "osd_monitor_enabled");
	GtkWidget* indicator_check = CreateCheckBox("Enable Indicator", "osd_indicator_enabled");

	AddTooltip(log_check, IDC_OSD_LOG);
	AddTooltip(monitor_check, IDC_OSD_MONITOR);
	AddTooltip(max_messages_label, max_messages_spin, IDC_OSD_MAX_LOG);

	InsertWidgetInTable(osd_table , fontname_label , fontname_file);
	InsertWidgetInTable(osd_table , fontsize_label , fontsize_text);
	InsertWidgetInTable(osd_table , transparency_label , transparency_slide);
	InsertWidgetInTable(osd_table , log_check);
	InsertWidgetInTable(osd_table , log_speed_label, log_speed_text);
	InsertWidgetInTable(osd_table , max_messages_label, max_messages_spin);
	InsertWidgetInTable(osd_table , monitor_check, indicator_check);
}
示例#2
0
void populate_gl_table(GtkWidget* gl_table)
{
	GtkWidget* gl_gs_label = left_label("Geometry Shader:");
	GtkWidget* gl_gs_combo = CreateComboBoxFromVector(theApp.m_gs_gl_ext, "override_geometry_shader");
	GtkWidget* gl_ils_label = left_label("Image Load Store:");
	GtkWidget* gl_ils_combo = CreateComboBoxFromVector(theApp.m_gs_gl_ext, "override_GL_ARB_shader_image_load_store");

	AddTooltip(gl_gs_label, gl_gs_combo, IDC_GEOMETRY_SHADER_OVERRIDE);
	AddTooltip(gl_ils_label, gl_ils_combo, IDC_IMAGE_LOAD_STORE);

	s_table_line = 0;
	InsertWidgetInTable(gl_table , gl_gs_label  , gl_gs_combo);
	InsertWidgetInTable(gl_table , gl_ils_label , gl_ils_combo);
}
示例#3
0
void populate_sw_table(GtkWidget* sw_table)
{
	GtkWidget* threads_label = left_label("Extra rendering threads:");
	GtkWidget* threads_spin  = CreateSpinButton(0, 32, "extrathreads");

	GtkWidget* aa_check         = CreateCheckBox("Edge anti-aliasing (AA1)", "aa1");
	GtkWidget* mipmap_check     = CreateCheckBox("Mipmapping", "mipmap");

	AddTooltip(aa_check, IDC_AA1);
	AddTooltip(mipmap_check, IDC_MIPMAP_SW);
	AddTooltip(threads_label, threads_spin, IDC_SWTHREADS);

	s_table_line = 0;
	InsertWidgetInTable(sw_table , threads_label, threads_spin);
	InsertWidgetInTable(sw_table , aa_check     , mipmap_check);
}
示例#4
0
void populate_shader_table(GtkWidget* shader_table)
{
	GtkWidget* shader            = CreateFileChooser(GTK_FILE_CHOOSER_ACTION_OPEN, "Select an external shader", "shaderfx_glsl");
	GtkWidget* shader_conf       = CreateFileChooser(GTK_FILE_CHOOSER_ACTION_OPEN, "Then select a config", "shaderfx_conf");
	GtkWidget* shader_label      = left_label("External shader glsl");
	GtkWidget* shader_conf_label = left_label("External shader conf");

	GtkWidget* shadeboost_check = CreateCheckBox("Shade boost", "ShadeBoost");
	GtkWidget* fxaa_check       = CreateCheckBox("Fxaa shader", "fxaa");
	GtkWidget* shaderfx_check   = CreateCheckBox("External shader", "shaderfx");

	GtkWidget* tv_shader_label  = left_label("TV shader:");
	GtkWidget* tv_shader        = CreateComboBoxFromVector(theApp.m_gs_tv_shaders, "TVShader");

	GtkWidget* linear_check     = CreateCheckBox("Texture Filtering of Display", "linear_present");

	// Shadeboost scale
	GtkWidget* sb_brightness       = CreateScale("ShadeBoost_Brightness");
	GtkWidget* sb_brightness_label = left_label("Shade Boost Brightness:");

	GtkWidget* sb_contrast         = CreateScale("ShadeBoost_Contrast");
	GtkWidget* sb_contrast_label   = left_label("Shade Boost Contrast:");

	GtkWidget* sb_saturation       = CreateScale("ShadeBoost_Saturation");
	GtkWidget* sb_saturation_label = left_label("Shade Boost Saturation:");

	AddTooltip(shadeboost_check, IDC_SHADEBOOST);
	AddTooltip(shaderfx_check, IDC_SHADER_FX);
	AddTooltip(fxaa_check, IDC_FXAA);
	AddTooltip(linear_check, IDC_LINEAR_PRESENT);

	s_table_line = 0;
	InsertWidgetInTable(shader_table , linear_check);
	InsertWidgetInTable(shader_table , fxaa_check);
	InsertWidgetInTable(shader_table , shadeboost_check);
	InsertWidgetInTable(shader_table , sb_brightness_label , sb_brightness);
	InsertWidgetInTable(shader_table , sb_contrast_label   , sb_contrast);
	InsertWidgetInTable(shader_table , sb_saturation_label , sb_saturation);
	InsertWidgetInTable(shader_table , shaderfx_check);
	InsertWidgetInTable(shader_table , shader_label        , shader);
	InsertWidgetInTable(shader_table , shader_conf_label   , shader_conf);
	InsertWidgetInTable(shader_table , tv_shader_label, tv_shader);
}
示例#5
0
void populate_hw_table(GtkWidget* hw_table)
{
	GtkWidget* filter_label     = left_label("Texture Filtering:");
	GtkWidget* filter_combo_box = CreateComboBoxFromVector(theApp.m_gs_filter, "filter");

	GtkWidget* fsaa_label     = left_label("Internal Resolution:");
	GtkWidget* fsaa_combo_box = CreateComboBoxFromVector(theApp.m_gs_upscale_multiplier, "upscale_multiplier");

	GtkWidget* af_label     = left_label("Anisotropic Filtering:");
	GtkWidget* af_combo_box = CreateComboBoxFromVector(theApp.m_gs_max_anisotropy, "MaxAnisotropy");

	GtkWidget* crc_label     = left_label("Automatic CRC level:");
	GtkWidget* crc_combo_box = CreateComboBoxFromVector(theApp.m_gs_crc_level, "crc_hack_level");

	GtkWidget* paltex_check     = CreateCheckBox("Allow 8 bits textures", "paltex");
	GtkWidget* acc_date_check   = CreateCheckBox("Accurate Date", "accurate_date");
	GtkWidget* large_fb_check   = CreateCheckBox("Large Framebuffer", "large_framebuffer");

	GtkWidget* acc_bld_label     = left_label("Blending Unit Accuracy:");
	GtkWidget* acc_bld_combo_box = CreateComboBoxFromVector(theApp.m_gs_acc_blend_level, "accurate_blending_unit");

	GtkWidget* hack_enable_check   = CreateCheckBox("Enable User Hacks", "UserHacks");

	GtkWidget* mipmap_label     = left_label("Mipmapping (Insert):");
	GtkWidget* mipmap_combo_box = CreateComboBoxFromVector(theApp.m_gs_hw_mipmapping, "mipmap_hw");

	// Some helper string
	AddTooltip(paltex_check, IDC_PALTEX);
	AddTooltip(acc_date_check, IDC_ACCURATE_DATE);
	AddTooltip(large_fb_check, IDC_LARGE_FB);
	AddTooltip(crc_label, crc_combo_box, IDC_CRC_LEVEL);
	AddTooltip(acc_bld_label, acc_bld_combo_box, IDC_ACCURATE_BLEND_UNIT);
	AddTooltip(filter_label, filter_combo_box, IDC_FILTER);
	AddTooltip(af_label, af_combo_box, IDC_AFCOMBO);
	gtk_widget_set_tooltip_text(hack_enable_check, "Enable the HW hack option panel");
	AddTooltip(mipmap_label, IDC_MIPMAP_HW);
	AddTooltip(mipmap_combo_box, IDC_MIPMAP_HW);

	s_table_line = 0;
	InsertWidgetInTable(hw_table , paltex_check  , acc_date_check);
	InsertWidgetInTable(hw_table , large_fb_check, hack_enable_check);
	InsertWidgetInTable(hw_table , fsaa_label    , fsaa_combo_box);
	InsertWidgetInTable(hw_table , filter_label  , filter_combo_box);
	InsertWidgetInTable(hw_table , af_label      , af_combo_box);
	InsertWidgetInTable(hw_table , acc_bld_label , acc_bld_combo_box);
	InsertWidgetInTable(hw_table , crc_label     , crc_combo_box);
	InsertWidgetInTable(hw_table , mipmap_label  , mipmap_combo_box);
}
示例#6
0
void populate_hack_table(GtkWidget* hack_table)
{
	GtkWidget* hack_offset_check   = CreateCheckBox("Half-pixel Offset Hack", "UserHacks_HalfPixelOffset");
	GtkWidget* hack_skipdraw_label = left_label("Skipdraw:");
	GtkWidget* hack_skipdraw_spin  = CreateSpinButton(0, 1000, "UserHacks_SkipDraw");
	GtkWidget* hack_enble_check    = CreateCheckBox("Enable User Hacks", "UserHacks");
	GtkWidget* hack_wild_check     = CreateCheckBox("Wild Arms Hack", "UserHacks_WildHack");
	GtkWidget* hack_tco_label      = left_label("Texture Offset: 0x");
	GtkWidget* hack_tco_entry      = CreateTextBox("UserHacks_TCOffset");
	GtkWidget* align_sprite_check  = CreateCheckBox("Align sprite hack", "UserHacks_align_sprite_X");
	GtkWidget* preload_gs_check    = CreateCheckBox("Preload Frame", "preload_frame_with_gs_data");
	GtkWidget* hack_unsafe_fbmask  = CreateCheckBox("Fast Accurate Blending", "UserHacks_unsafe_fbmask");

	GtkWidget* hack_sprite_box     = CreateComboBoxFromVector(theApp.m_gs_hack, "UserHacks_SpriteHack");
	GtkWidget* hack_sprite_label   = left_label("Alpha-Sprite Hack:");
	GtkWidget* stretch_hack_box    = CreateComboBoxFromVector(theApp.m_gs_hack, "UserHacks_round_sprite_offset");
	GtkWidget* stretch_hack_label  = left_label("Align Sprite Texture:");

	// Reuse windows helper string :)
	AddTooltip(hack_offset_check, IDC_OFFSETHACK);
	AddTooltip(hack_skipdraw_label, IDC_SKIPDRAWHACK);
	AddTooltip(hack_skipdraw_spin, IDC_SKIPDRAWHACK);
	gtk_widget_set_tooltip_text(hack_enble_check, "Allows the use of the hack below");
	AddTooltip(hack_wild_check, IDC_WILDHACK);
	AddTooltip(hack_sprite_label, hack_sprite_box, IDC_SPRITEHACK);
	AddTooltip(hack_tco_label, IDC_TCOFFSETX);
	AddTooltip(hack_tco_entry, IDC_TCOFFSETX);
	AddTooltip(align_sprite_check, IDC_ALIGN_SPRITE);
	AddTooltip(stretch_hack_label, stretch_hack_box, IDC_ROUND_SPRITE);
	AddTooltip(preload_gs_check, IDC_PRELOAD_GS);


	s_table_line = 0;
	InsertWidgetInTable(hack_table , hack_enble_check);
	InsertWidgetInTable(hack_table , hack_wild_check     , align_sprite_check);
	InsertWidgetInTable(hack_table , hack_offset_check   , preload_gs_check);
	InsertWidgetInTable(hack_table , hack_unsafe_fbmask);
	InsertWidgetInTable(hack_table , hack_sprite_label   , hack_sprite_box );
	InsertWidgetInTable(hack_table , stretch_hack_label  , stretch_hack_box );
	InsertWidgetInTable(hack_table , hack_skipdraw_label , hack_skipdraw_spin);
	InsertWidgetInTable(hack_table , hack_tco_label      , hack_tco_entry);
}
void populate_hw_table(GtkWidget* hw_table)
{
	GtkWidget* filter_label     = gtk_label_new ("Texture Filtering:");
	GtkWidget* filter_combo_box = CreateComboBoxFromVector(theApp.m_gs_filter, "filter", 2);

	GtkWidget* af_label     = gtk_label_new("Anisotropic Filtering:");
	GtkWidget* af_combo_box = CreateComboBoxFromVector(theApp.m_gs_max_anisotropy, "MaxAnisotropy", 1);

	GtkWidget* crc_label     = gtk_label_new("Automatic CRC level:");
	GtkWidget* crc_combo_box = CreateComboBoxFromVector(theApp.m_gs_crc_level, "crc_hack_level", 3);

	GtkWidget* paltex_check     = CreateCheckBox("Allow 8 bits textures", "paltex");
	GtkWidget* acc_date_check   = CreateCheckBox("Accurate Date", "accurate_date", false);
	GtkWidget* tc_depth_check   = CreateCheckBox("Full Depth Emulation", "texture_cache_depth", true);

	GtkWidget* acc_bld_label     = gtk_label_new("Blending Unit Accuracy:");
	GtkWidget* acc_bld_combo_box = CreateComboBoxFromVector(theApp.m_gs_acc_blend_level, "accurate_blending_unit", 1);

	// Some helper string
	AddTooltip(paltex_check, IDC_PALTEX);
	AddTooltip(acc_date_check, IDC_ACCURATE_DATE);
	AddTooltip(crc_label, crc_combo_box, IDC_CRC_LEVEL);
	AddTooltip(acc_bld_label, acc_bld_combo_box, IDC_ACCURATE_BLEND_UNIT);
	AddTooltip(tc_depth_check, IDC_TC_DEPTH);
	AddTooltip(filter_label, filter_combo_box, IDC_FILTER);

	s_table_line = 0;
	InsertWidgetInTable(hw_table, paltex_check, tc_depth_check);
	InsertWidgetInTable(hw_table, acc_date_check);
	InsertWidgetInTable(hw_table, acc_bld_label, acc_bld_combo_box);
	InsertWidgetInTable(hw_table, filter_label, filter_combo_box);
	InsertWidgetInTable(hw_table, af_label, af_combo_box);
	InsertWidgetInTable(hw_table, crc_label, crc_combo_box);
}
示例#8
0
void populate_main_table(GtkWidget* main_table)
{
	GtkWidget* render_label     = left_label("Renderer:");
	GtkWidget* render_combo_box = CreateComboBoxFromVector(theApp.m_gs_renderers, "Renderer");
	GtkWidget* interlace_label     = left_label("Interlacing (F5):");
	GtkWidget* interlace_combo_box = CreateComboBoxFromVector(theApp.m_gs_interlace, "interlace");
	GtkWidget* filter_label     = left_label("Texture Filtering:");
	GtkWidget* filter_combo_box = CreateComboBoxFromVector(theApp.m_gs_bifilter, "filter");

	AddTooltip(filter_label, filter_combo_box, IDC_FILTER);

	s_table_line = 0;
	InsertWidgetInTable(main_table, render_label, render_combo_box);
	InsertWidgetInTable(main_table, interlace_label, interlace_combo_box);
	InsertWidgetInTable(main_table, filter_label  , filter_combo_box);
}
void populate_hack_table(GtkWidget* hack_table)
{
	GtkWidget* hack_offset_check   = CreateCheckBox("Offset Hack", "UserHacks_HalfPixelOffset");
	GtkWidget* hack_skipdraw_label = gtk_label_new("Skipdraw:");
	GtkWidget* hack_skipdraw_spin  = CreateSpinButton(0, 1000, "UserHacks_SkipDraw");
	GtkWidget* hack_enble_check    = CreateCheckBox("Enable User Hacks", "UserHacks");
	GtkWidget* hack_wild_check     = CreateCheckBox("Wild arm Hack", "UserHacks_WildHack");
	GtkWidget* hack_tco_label      = gtk_label_new("Texture Offset: 0x");
	GtkWidget* hack_tco_entry      = CreateTextBox("UserHacks_TCOffset");
	GtkWidget* align_sprite_check  = CreateCheckBox("Align sprite hack", "UserHacks_align_sprite_X");

	GtkWidget* hack_sprite_box     = CreateComboBoxFromVector(theApp.m_gs_hack, "UserHacks_SpriteHack");
	GtkWidget* hack_sprite_label   = gtk_label_new("Alpha-Sprite Hack:");
	GtkWidget* stretch_hack_box    = CreateComboBoxFromVector(theApp.m_gs_hack, "UserHacks_round_sprite_offset");
	GtkWidget* stretch_hack_label  = gtk_label_new("Align Sprite Texture:");

	// Reuse windows helper string :)
	AddTooltip(hack_offset_check, IDC_TCOFFSETX);
	AddTooltip(hack_skipdraw_label, IDC_SKIPDRAWHACK);
	AddTooltip(hack_skipdraw_spin, IDC_SKIPDRAWHACK);
	gtk_widget_set_tooltip_text(hack_enble_check, "Allow to use hack below");
	AddTooltip(hack_wild_check, IDC_WILDHACK);
	AddTooltip(hack_sprite_label, hack_sprite_box, IDC_SPRITEHACK);
	AddTooltip(hack_tco_label, IDC_TCOFFSETX);
	AddTooltip(hack_tco_entry, IDC_TCOFFSETX);
	AddTooltip(align_sprite_check, IDC_ALIGN_SPRITE);
	AddTooltip(stretch_hack_label, stretch_hack_box, IDC_ROUND_SPRITE);


	s_table_line = 0;
	InsertWidgetInTable(hack_table , hack_enble_check);
	InsertWidgetInTable(hack_table , hack_wild_check     , align_sprite_check);
	InsertWidgetInTable(hack_table , hack_sprite_label   , hack_sprite_box );
	InsertWidgetInTable(hack_table , stretch_hack_label  , stretch_hack_box );
	InsertWidgetInTable(hack_table , hack_skipdraw_label , hack_skipdraw_spin);
	InsertWidgetInTable(hack_table , hack_offset_check);
	InsertWidgetInTable(hack_table , hack_tco_label      , hack_tco_entry);
}
示例#10
0
void populate_hw_table(GtkWidget* hw_table)
{
	GtkWidget* filter_label     = left_label("Texture Filtering:");
	GtkWidget* filter_combo_box = CreateComboBoxFromVector(theApp.m_gs_filter, "filter", 2);

	GtkWidget* fsaa_label     = left_label("Internal Resolution:");
	GtkWidget* fsaa_combo_box = CreateComboBoxFromVector(theApp.m_gs_upscale_multiplier, "upscale_multiplier", 1);

	GtkWidget* af_label     = left_label("Anisotropic Filtering:");
	GtkWidget* af_combo_box = CreateComboBoxFromVector(theApp.m_gs_max_anisotropy, "MaxAnisotropy", 0);

	GtkWidget* crc_label     = left_label("Automatic CRC level:");
	GtkWidget* crc_combo_box = CreateComboBoxFromVector(theApp.m_gs_crc_level, "crc_hack_level", 3);

	GtkWidget* paltex_check     = CreateCheckBox("Allow 8 bits textures", "paltex");
	GtkWidget* acc_date_check   = CreateCheckBox("Accurate Date", "accurate_date", false);

	GtkWidget* acc_bld_label     = left_label("Blending Unit Accuracy:");
	GtkWidget* acc_bld_combo_box = CreateComboBoxFromVector(theApp.m_gs_acc_blend_level, "accurate_blending_unit", 1);

	// Some helper string
	AddTooltip(paltex_check, IDC_PALTEX);
	AddTooltip(acc_date_check, IDC_ACCURATE_DATE);
	AddTooltip(crc_label, crc_combo_box, IDC_CRC_LEVEL);
	AddTooltip(acc_bld_label, acc_bld_combo_box, IDC_ACCURATE_BLEND_UNIT);
	AddTooltip(filter_label, filter_combo_box, IDC_FILTER);
	AddTooltip(af_label, af_combo_box, IDC_AFCOMBO);

	s_table_line = 0;
	InsertWidgetInTable(hw_table , paltex_check  , acc_date_check);
	InsertWidgetInTable(hw_table , fsaa_label    , fsaa_combo_box);
	InsertWidgetInTable(hw_table , filter_label  , filter_combo_box);
	InsertWidgetInTable(hw_table , af_label      , af_combo_box);
	InsertWidgetInTable(hw_table , acc_bld_label , acc_bld_combo_box);
	InsertWidgetInTable(hw_table , crc_label     , crc_combo_box);
}
示例#11
0
void AddTooltip(GtkWidget* w1, GtkWidget* w2, int idc)
{
	AddTooltip(w1, idc);
	AddTooltip(w2, idc);
}
示例#12
0
void populate_hack_table(GtkWidget* hack_table)
{
	GtkWidget* hack_offset_label   = left_label("Half-pixel Offset Hack:");
	GtkWidget* hack_offset_box     = CreateComboBoxFromVector(theApp.m_gs_offset_hack, "UserHacks_HalfPixelOffset");
	GtkWidget* hack_skipdraw_label = left_label("Skipdraw:");
	GtkWidget* hack_skipdraw_spin  = CreateSpinButton(0, 1000, "UserHacks_SkipDraw");
	GtkWidget* hack_wild_check     = CreateCheckBox("Wild Arms Hack", "UserHacks_WildHack");
	GtkWidget* hack_tco_label      = left_label("Texture Offset: 0x");
	GtkWidget* hack_tco_entry      = CreateTextBox("UserHacks_TCOffset");
	GtkWidget* align_sprite_check  = CreateCheckBox("Align sprite hack", "UserHacks_align_sprite_X");
	GtkWidget* preload_gs_check    = CreateCheckBox("Preload Frame", "preload_frame_with_gs_data");
	GtkWidget* hack_fast_inv       = CreateCheckBox("Fast Texture Invalidation", "UserHacks_DisablePartialInvalidation");
	GtkWidget* hack_depth_check    = CreateCheckBox("Disable Depth Emulation", "UserHacks_DisableDepthSupport");
	GtkWidget* hack_auto_flush     = CreateCheckBox("Auto Flush Primitives", "UserHacks_AutoFlush");
	GtkWidget* hack_unscale_prim   = CreateCheckBox("Unscale Point&Line Primitives", "UserHacks_unscale_point_line");
	GtkWidget* hack_merge_sprite   = CreateCheckBox("Merge Sprite", "UserHacks_merge_pp_sprite");
	GtkWidget* hack_wrap_mem       = CreateCheckBox("Memory Wrapping", "wrap_gs_mem");

	GtkWidget* hack_sprite_box     = CreateComboBoxFromVector(theApp.m_gs_hack, "UserHacks_SpriteHack");
	GtkWidget* hack_sprite_label   = left_label("Alpha-Sprite Hack:");
	GtkWidget* stretch_hack_box    = CreateComboBoxFromVector(theApp.m_gs_hack, "UserHacks_round_sprite_offset");
	GtkWidget* stretch_hack_label  = left_label("Align Sprite Texture:");
	GtkWidget* trilinear_box       = CreateComboBoxFromVector(theApp.m_gs_trifilter, "UserHacks_TriFilter");
	GtkWidget* trilinear_label     = left_label("Trilinear Filtering:");

	// Reuse windows helper string :)
	AddTooltip(hack_offset_label, IDC_OFFSETHACK);
	AddTooltip(hack_offset_box, IDC_OFFSETHACK);
	AddTooltip(hack_skipdraw_label, IDC_SKIPDRAWHACK);
	AddTooltip(hack_skipdraw_spin, IDC_SKIPDRAWHACK);
	AddTooltip(hack_wild_check, IDC_WILDHACK);
	AddTooltip(hack_sprite_label, hack_sprite_box, IDC_SPRITEHACK);
	AddTooltip(hack_tco_label, IDC_TCOFFSETX);
	AddTooltip(hack_tco_entry, IDC_TCOFFSETX);
	AddTooltip(align_sprite_check, IDC_ALIGN_SPRITE);
	AddTooltip(stretch_hack_label, stretch_hack_box, IDC_ROUND_SPRITE);
	AddTooltip(preload_gs_check, IDC_PRELOAD_GS);
	AddTooltip(hack_fast_inv, IDC_FAST_TC_INV);
	AddTooltip(hack_depth_check, IDC_TC_DEPTH);
	AddTooltip(hack_auto_flush, IDC_AUTO_FLUSH);
	AddTooltip(hack_unscale_prim, IDC_UNSCALE_POINT_LINE);
	AddTooltip(hack_merge_sprite, IDC_MERGE_PP_SPRITE);
	AddTooltip(hack_wrap_mem, IDC_MEMORY_WRAPPING);
	AddTooltip(trilinear_box, IDC_TRI_FILTER);
	AddTooltip(trilinear_label, IDC_TRI_FILTER);


	s_table_line = 0;
	// Hack
	InsertWidgetInTable(hack_table , hack_fast_inv       , hack_auto_flush);
	InsertWidgetInTable(hack_table , hack_depth_check    , preload_gs_check);
	InsertWidgetInTable(hack_table , hack_wrap_mem);
	// Upscaling hack
	InsertWidgetInTable(hack_table , hack_wild_check     , align_sprite_check);
	InsertWidgetInTable(hack_table , hack_unscale_prim   , hack_merge_sprite);
	InsertWidgetInTable(hack_table , hack_offset_label   , hack_offset_box);
	InsertWidgetInTable(hack_table , hack_sprite_label   , hack_sprite_box );
	InsertWidgetInTable(hack_table , stretch_hack_label  , stretch_hack_box );
	InsertWidgetInTable(hack_table , hack_skipdraw_label , hack_skipdraw_spin);
	InsertWidgetInTable(hack_table , hack_tco_label      , hack_tco_entry);
	InsertWidgetInTable(hack_table , trilinear_label     , trilinear_box);
}
示例#13
0
void GSHacksDlg::OnInit()
{
    HWND hwnd_renderer = GetDlgItem(GetParent(m_hWnd), IDC_RENDERER);
    int renderer = SendMessage(hwnd_renderer, CB_GETITEMDATA, SendMessage(hwnd_renderer, CB_GETCURSEL, 0, 0), 0);
    // It can only be accessed with a HW renderer, so this is sufficient.
    bool dx9 = renderer == 0;
    // bool dx11 = renderer == 3;
    bool ogl = renderer == 12;
    unsigned short cb = 0;

    if(dx9) for(unsigned short i = 0; i < 17; i++)
        {
            if( i == 1) continue;

            int depth = GSDevice9::GetMaxDepth(i, adapter_id);

            if(depth)
            {
                char text[32] = {0};
                sprintf(text, depth == 32 ? "%dx Z-32" : "%dx Z-24", i);
                SendMessage(GetDlgItem(m_hWnd, IDC_MSAACB), CB_ADDSTRING, 0, (LPARAM)text);

                msaa2cb[i] = cb;
                cb2msaa[cb] = i;
                cb++;
            }
        }
    else for(unsigned short j = 0; j < 5; j++) // TODO: Make the same kind of check for d3d11, eventually....
        {
            unsigned short i = j == 0 ? 0 : 1 << j;

            msaa2cb[i] = j;
            cb2msaa[j] = i;

            char text[32] = {0};
            sprintf(text, "%dx ", i);

            SendMessage(GetDlgItem(m_hWnd, IDC_MSAACB), CB_ADDSTRING, 0, (LPARAM)text);
        }

    SendMessage(GetDlgItem(m_hWnd, IDC_MSAACB), CB_SETCURSEL, msaa2cb[min(theApp.GetConfig("UserHacks_MSAA", 0), 16)], 0);

    CheckDlgButton(m_hWnd, IDC_ALPHAHACK, theApp.GetConfig("UserHacks_AlphaHack", 0));
    CheckDlgButton(m_hWnd, IDC_OFFSETHACK, theApp.GetConfig("UserHacks_HalfPixelOffset", 0));
    CheckDlgButton(m_hWnd, IDC_WILDHACK, theApp.GetConfig("UserHacks_WildHack", 0));
    CheckDlgButton(m_hWnd, IDC_ALPHASTENCIL, theApp.GetConfig("UserHacks_AlphaStencil", 0));
    CheckDlgButton(m_hWnd, IDC_PRELOAD_GS, theApp.GetConfig("preload_frame_with_gs_data", 0));
    CheckDlgButton(m_hWnd, IDC_ALIGN_SPRITE, theApp.GetConfig("UserHacks_align_sprite_X", 0));

    ComboBoxInit(IDC_ROUND_SPRITE, theApp.m_gs_hack, theApp.GetConfig("UserHacks_round_sprite_offset", 0));
    ComboBoxInit(IDC_SPRITEHACK, theApp.m_gs_hack, theApp.GetConfig("UserHacks_SpriteHack", 0));

    SendMessage(GetDlgItem(m_hWnd, IDC_SKIPDRAWHACK), UDM_SETRANGE, 0, MAKELPARAM(1000, 0));
    SendMessage(GetDlgItem(m_hWnd, IDC_SKIPDRAWHACK), UDM_SETPOS, 0, MAKELPARAM(theApp.GetConfig("UserHacks_SkipDraw", 0), 0));

    SendMessage(GetDlgItem(m_hWnd, IDC_TCOFFSETX), UDM_SETRANGE, 0, MAKELPARAM(10000, 0));
    SendMessage(GetDlgItem(m_hWnd, IDC_TCOFFSETX), UDM_SETPOS, 0, MAKELPARAM(theApp.GetConfig("UserHacks_TCOffset", 0) & 0xFFFF, 0));

    SendMessage(GetDlgItem(m_hWnd, IDC_TCOFFSETY), UDM_SETRANGE, 0, MAKELPARAM(10000, 0));
    SendMessage(GetDlgItem(m_hWnd, IDC_TCOFFSETY), UDM_SETPOS, 0, MAKELPARAM((theApp.GetConfig("UserHacks_TCOffset", 0) >> 16) & 0xFFFF, 0));

    ShowWindow(GetDlgItem(m_hWnd, IDC_ALPHASTENCIL), ogl ? SW_HIDE : SW_SHOW);
    ShowWindow(GetDlgItem(m_hWnd, IDC_ALPHAHACK), ogl ? SW_HIDE : SW_SHOW);

    AddTooltip(IDC_SKIPDRAWHACKEDIT);
    AddTooltip(IDC_SKIPDRAWHACK);
    AddTooltip(IDC_ALPHAHACK);
    AddTooltip(IDC_OFFSETHACK);
    AddTooltip(IDC_SPRITEHACK);
    AddTooltip(IDC_WILDHACK);
    AddTooltip(IDC_MSAACB);
    AddTooltip(IDC_ALPHASTENCIL);
    AddTooltip(IDC_ALIGN_SPRITE);
    AddTooltip(IDC_ROUND_SPRITE);
    AddTooltip(IDC_TCOFFSETX);
    AddTooltip(IDC_TCOFFSETX2);
    AddTooltip(IDC_TCOFFSETY);
    AddTooltip(IDC_TCOFFSETY2);
    AddTooltip(IDC_PRELOAD_GS);
}
示例#14
0
void GSSettingsDlg::OnInit()
{
    __super::OnInit();

    CComPtr<IDirect3D9> d3d9;

    d3d9.Attach(Direct3DCreate9(D3D_SDK_VERSION));

    CComPtr<IDXGIFactory1> dxgi_factory;

    if(GSUtil::CheckDXGI())
    {
        CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&dxgi_factory);
    }
    adapters.clear();
    adapters.push_back(Adapter("Default Hardware Device", "default", GSUtil::CheckDirect3D11Level(NULL, D3D_DRIVER_TYPE_HARDWARE)));
    adapters.push_back(Adapter("Reference Device", "ref", GSUtil::CheckDirect3D11Level(NULL, D3D_DRIVER_TYPE_REFERENCE)));

    if(dxgi_factory)
    {
        for(int i = 0;; i++)
        {
            CComPtr<IDXGIAdapter1> adapter;

            if(S_OK != dxgi_factory->EnumAdapters1(i, &adapter))
                break;

            DXGI_ADAPTER_DESC1 desc;

            HRESULT hr = adapter->GetDesc1(&desc);

            if(S_OK == hr)
            {
                D3D_FEATURE_LEVEL level = GSUtil::CheckDirect3D11Level(adapter, D3D_DRIVER_TYPE_UNKNOWN);
                // GSDX isn't unicode!?
#if 1
                int size = WideCharToMultiByte(CP_ACP, 0, desc.Description, sizeof(desc.Description), NULL, 0, NULL, NULL);
                char *buf = new char[size];
                WideCharToMultiByte(CP_ACP, 0, desc.Description, sizeof(desc.Description), buf, size, NULL, NULL);
                adapters.push_back(Adapter(buf, GSAdapter(desc), level));
                delete[] buf;
#else
                adapters.push_back(Adapter(desc.Description, GSAdapter(desc), level));
#endif
            }
        }
    }
    else if(d3d9)
    {
        int n = d3d9->GetAdapterCount();
        for(int i = 0; i < n; i++)
        {
            D3DADAPTER_IDENTIFIER9 desc;

            if(D3D_OK != d3d9->GetAdapterIdentifier(i, 0, &desc))
                break;

            // GSDX isn't unicode!?
#if 0
            wchar_t buf[sizeof desc.Description * sizeof(WCHAR)];
            MultiByteToWideChar(CP_ACP /* I have no idea if this is right */, 0, desc.Description, sizeof(desc.Description), buf, sizeof buf / sizeof *buf);
            adapters.push_back(Adapter(buf, GSAdapter(desc), (D3D_FEATURE_LEVEL)0));
#else
            adapters.push_back(Adapter(desc.Description, GSAdapter(desc), (D3D_FEATURE_LEVEL)0));
#endif
        }
    }

    std::string adapter_setting = theApp.GetConfig("Adapter", "default");
    vector<GSSetting> adapter_settings;
    unsigned int adapter_sel = 0;

    for(unsigned int i = 0; i < adapters.size(); i++)
    {
        if(adapters[i].id == adapter_setting)
        {
            adapter_sel = i;
        }

        adapter_settings.push_back(GSSetting(i, adapters[i].name.c_str(), ""));
    }

    std::string ocldev = theApp.GetConfig("ocldev", "");

    unsigned int ocl_sel = 0;

    for(unsigned int i = 0; i < m_ocl_devs.size(); i++)
    {
        if(ocldev == m_ocl_devs[i].name)
        {
            ocl_sel = i;

            break;
        }
    }

    ComboBoxInit(IDC_ADAPTER, adapter_settings, adapter_sel);
    ComboBoxInit(IDC_OPENCL_DEVICE, m_ocl_devs, ocl_sel);

    UpdateRenderers();

    ComboBoxInit(IDC_INTERLACE, theApp.m_gs_interlace, theApp.GetConfig("Interlace", 7)); // 7 = "auto", detects interlace based on SMODE2 register
    ComboBoxInit(IDC_UPSCALE_MULTIPLIER, theApp.m_gs_upscale_multiplier, theApp.GetConfig("upscale_multiplier", 1));
    ComboBoxInit(IDC_AFCOMBO, theApp.m_gs_max_anisotropy, theApp.GetConfig("MaxAnisotropy", 0));
    ComboBoxInit(IDC_FILTER, theApp.m_gs_filter, theApp.GetConfig("filter", 2));
    ComboBoxInit(IDC_ACCURATE_BLEND_UNIT, theApp.m_gs_acc_blend_level, theApp.GetConfig("accurate_blending_unit", 1));
    ComboBoxInit(IDC_CRC_LEVEL, theApp.m_gs_crc_level, theApp.GetConfig("crc_hack_level", 3));

    CheckDlgButton(m_hWnd, IDC_PALTEX, theApp.GetConfig("paltex", 0));
    CheckDlgButton(m_hWnd, IDC_LOGZ, theApp.GetConfig("logz", 1));
    CheckDlgButton(m_hWnd, IDC_FBA, theApp.GetConfig("fba", 1));
    CheckDlgButton(m_hWnd, IDC_AA1, theApp.GetConfig("aa1", 0));
    CheckDlgButton(m_hWnd, IDC_MIPMAP, theApp.GetConfig("mipmap", 1));
    CheckDlgButton(m_hWnd, IDC_ACCURATE_DATE, theApp.GetConfig("accurate_date", 0));
    CheckDlgButton(m_hWnd, IDC_TC_DEPTH, theApp.GetConfig("texture_cache_depth", 0));

    // Shade Boost
    CheckDlgButton(m_hWnd, IDC_SHADEBOOST, theApp.GetConfig("ShadeBoost", 0));

    // FXAA shader
    CheckDlgButton(m_hWnd, IDC_FXAA, theApp.GetConfig("Fxaa", 0));

    // External FX shader
    CheckDlgButton(m_hWnd, IDC_SHADER_FX, theApp.GetConfig("shaderfx", 0));
    SendMessage(GetDlgItem(m_hWnd, IDC_SHADER_FX_EDIT), WM_SETTEXT, 0, (LPARAM)theApp.GetConfig("shaderfx_glsl", "shaders\\GSdx.fx").c_str());
    SendMessage(GetDlgItem(m_hWnd, IDC_SHADER_FX_CONF_EDIT), WM_SETTEXT, 0, (LPARAM)theApp.GetConfig("shaderfx_conf", "shaders\\GSdx_FX_Settings.ini").c_str());

    // Hacks
    CheckDlgButton(m_hWnd, IDC_HACKS_ENABLED, theApp.GetConfig("UserHacks", 0));

    SendMessage(GetDlgItem(m_hWnd, IDC_RESX), UDM_SETRANGE, 0, MAKELPARAM(8192, 256));
    SendMessage(GetDlgItem(m_hWnd, IDC_RESX), UDM_SETPOS, 0, MAKELPARAM(theApp.GetConfig("resx", 1024), 0));

    SendMessage(GetDlgItem(m_hWnd, IDC_RESY), UDM_SETRANGE, 0, MAKELPARAM(8192, 256));
    SendMessage(GetDlgItem(m_hWnd, IDC_RESY), UDM_SETPOS, 0, MAKELPARAM(theApp.GetConfig("resy", 1024), 0));

    SendMessage(GetDlgItem(m_hWnd, IDC_SWTHREADS), UDM_SETRANGE, 0, MAKELPARAM(16, 0));
    SendMessage(GetDlgItem(m_hWnd, IDC_SWTHREADS), UDM_SETPOS, 0, MAKELPARAM(theApp.GetConfig("extrathreads", 0), 0));

    AddTooltip(IDC_FILTER);
    AddTooltip(IDC_CRC_LEVEL);
    AddTooltip(IDC_PALTEX);
    AddTooltip(IDC_ACCURATE_DATE);
    AddTooltip(IDC_ACCURATE_BLEND_UNIT);
    AddTooltip(IDC_TC_DEPTH);
    AddTooltip(IDC_AFCOMBO);
    AddTooltip(IDC_AA1);
    AddTooltip(IDC_MIPMAP);
    AddTooltip(IDC_SWTHREADS);
    AddTooltip(IDC_SWTHREADS_EDIT);
    AddTooltip(IDC_SHADEBOOST);
    AddTooltip(IDC_SHADER_FX);
    AddTooltip(IDC_FXAA);
    AddTooltip(IDC_FBA);
    AddTooltip(IDC_LOGZ);

    UpdateControls();
}
示例#15
0
void populate_hack_table(GtkWidget* hack_table)
{
    GtkWidget* hack_offset_check   = CreateCheckBox("Half-pixel Offset Hack", "UserHacks_HalfPixelOffset");
    GtkWidget* hack_skipdraw_label = left_label("Skipdraw:");
    GtkWidget* hack_skipdraw_spin  = CreateSpinButton(0, 1000, "UserHacks_SkipDraw");
    GtkWidget* hack_wild_check     = CreateCheckBox("Wild Arms Hack", "UserHacks_WildHack");
    GtkWidget* hack_tco_label      = left_label("Texture Offset: 0x");
    GtkWidget* hack_tco_entry      = CreateTextBox("UserHacks_TCOffset");
    GtkWidget* align_sprite_check  = CreateCheckBox("Align sprite hack", "UserHacks_align_sprite_X");
    GtkWidget* preload_gs_check    = CreateCheckBox("Preload Frame", "preload_frame_with_gs_data");
    GtkWidget* hack_safe_fbmask    = CreateCheckBox("Safe Accurate Blending", "UserHacks_safe_fbmask");
    GtkWidget* hack_fast_inv       = CreateCheckBox("Fast Texture Invalidation", "UserHacks_DisablePartialInvalidation");
    GtkWidget* hack_depth_check    = CreateCheckBox("Disable Depth Emulation", "UserHacks_DisableDepthSupport");

    GtkWidget* hack_sprite_box     = CreateComboBoxFromVector(theApp.m_gs_hack, "UserHacks_SpriteHack");
    GtkWidget* hack_sprite_label   = left_label("Alpha-Sprite Hack:");
    GtkWidget* stretch_hack_box    = CreateComboBoxFromVector(theApp.m_gs_hack, "UserHacks_round_sprite_offset");
    GtkWidget* stretch_hack_label  = left_label("Align Sprite Texture:");

    // Reuse windows helper string :)
    AddTooltip(hack_offset_check, IDC_OFFSETHACK);
    AddTooltip(hack_skipdraw_label, IDC_SKIPDRAWHACK);
    AddTooltip(hack_skipdraw_spin, IDC_SKIPDRAWHACK);
    AddTooltip(hack_wild_check, IDC_WILDHACK);
    AddTooltip(hack_sprite_label, hack_sprite_box, IDC_SPRITEHACK);
    AddTooltip(hack_tco_label, IDC_TCOFFSETX);
    AddTooltip(hack_tco_entry, IDC_TCOFFSETX);
    AddTooltip(align_sprite_check, IDC_ALIGN_SPRITE);
    AddTooltip(stretch_hack_label, stretch_hack_box, IDC_ROUND_SPRITE);
    AddTooltip(preload_gs_check, IDC_PRELOAD_GS);
    AddTooltip(hack_safe_fbmask, IDC_SAFE_FBMASK);
    AddTooltip(hack_fast_inv, IDC_FAST_TC_INV);
    AddTooltip(hack_depth_check, IDC_TC_DEPTH);


    s_table_line = 0;
    InsertWidgetInTable(hack_table , hack_wild_check     , align_sprite_check);
    InsertWidgetInTable(hack_table , hack_offset_check   , preload_gs_check);
    InsertWidgetInTable(hack_table , hack_safe_fbmask    , hack_fast_inv);
    InsertWidgetInTable(hack_table , hack_depth_check);
    InsertWidgetInTable(hack_table , hack_sprite_label   , hack_sprite_box );
    InsertWidgetInTable(hack_table , stretch_hack_label  , stretch_hack_box );
    InsertWidgetInTable(hack_table , hack_skipdraw_label , hack_skipdraw_spin);
    InsertWidgetInTable(hack_table , hack_tco_label      , hack_tco_entry);
}