C# Code.Core类代码示例

        public RemoteHostSelect(Core core, MainWindow main)
        {
            InitializeComponent();

            Icon = global::renderdocui.Properties.Resources.icon;

            hostname.Font =
                hosts.Font =
                core.Config.PreferredFont;

            m_Core = core;
            m_Main = main;

            hosts.BeginInit();

            // localhost should always be available
            if (!m_Core.Config.RecentHosts.Contains("localhost"))
                m_Core.Config.RecentHosts.Add("localhost");

            foreach (var h in m_Core.Config.RecentHosts)
            {
                AddHost(h);
            }

            hosts.EndInit();
        }

        public LiveCapture(Core core, string host, UInt32 remoteIdent, MainWindow main)
        {
            InitializeComponent();

            m_Core = core;
            m_Main = main;

            this.DoubleBuffered = true;
            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint | ControlStyles.OptimizedDoubleBuffer, true);

            Icon = global::renderdocui.Properties.Resources.icon;

            m_Connection = null;
            m_Host = host;
            m_RemoteIdent = remoteIdent;

            m_ConnectThread = null;

            Text = (m_Host != "" ? m_Host + " - " : "") + "Connecting...";
            connectionStatus.Text = "Connecting...";
            connectionIcon.Image = global::renderdocui.Properties.Resources.hourglass;

            thumbs = new ImageList();
            thumbs.ColorDepth = ColorDepth.Depth24Bit;

            thumbs.ImageSize = new Size(256, 144);
            captures.TileSize = new Size(400, 160);
            captures.LargeImageList = thumbs;

            captures.Columns.AddRange(new ColumnHeader[] { new ColumnHeader(), new ColumnHeader(), new ColumnHeader() });
        }

        public ResourcePreview(Core core, ReplayOutput output)
        {
            InitializeComponent();

            descriptionLabel.Font = core.Config.PreferredFont;

            m_Name = "Unbound";
            m_Width = 1;
            m_Height = 1;
            m_Depth = 1;
            m_NumMips = 0;
            m_Unbound = true;
            thumbnail.Painting = false;

            m_Unbound = true;

            slotLabel.Text = "0";

            this.DoubleBuffered = true;

            SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint, true);

            m_Handle = thumbnail.Handle;

            m_Core = core;
            m_Output = output;

            Selected = false;
        }

        public MainWindow(Core core, string initFilename, bool temp)
        {
            InitializeComponent();

            Icon = global::renderdocui.Properties.Resources.icon;

            renderdocplugin.PluginHelpers.GetPlugins();

            statusText.Text = "";

            SetTitle();

            Application.AddMessageFilter(this);

            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);

            m_Core = core;
            m_InitFilename = initFilename;
            OwnTemporaryLog = temp;

            logStatisticsToolStripMenuItem.Enabled = false;

            resolveSymbolsToolStripMenuItem.Enabled = false;
            resolveSymbolsToolStripMenuItem.Text = "Resolve Symbols";

            m_Core.CaptureDialog = new Dialogs.CaptureDialog(m_Core, OnCaptureTrigger, OnInjectTrigger);

            m_Core.AddLogViewer(this);
            m_Core.AddLogProgressListener(this);
        }

        public ConstantBufferPreviewer(Core c, ShaderStageType stage, UInt32 slot, UInt32 idx)
        {
            InitializeComponent();

            if (SystemInformation.HighContrast)
                toolStrip1.Renderer = new ToolStripSystemRenderer();

            m_Core = c;
            Stage = stage;
            Slot = slot;
            ArrayIdx = idx;
            shader = m_Core.CurPipelineState.GetShader(stage);
            entryPoint = m_Core.CurPipelineState.GetShaderEntryPoint(stage);
            UpdateLabels();

            ulong offs = 0;
            ulong size = 0;
            m_Core.CurPipelineState.GetConstantBuffer(Stage, Slot, ArrayIdx, out cbuffer, out offs, out size);

            m_Core.Renderer.BeginInvoke((ReplayRenderer r) =>
            {
                SetVariables(r.GetCBufferVariableContents(shader, entryPoint, Slot, cbuffer, offs));
            });

            m_Core.AddLogViewer(this);
        }

        public EventBrowser(Core core)
        {
            InitializeComponent();

            Icon = global::renderdocui.Properties.Resources.icon;

            jumpToEID.Font =
                findEvent.Font =
                eventView.Font = 
                core.Config.PreferredFont;

            HideJumpAndFind();
            ClearBookmarks();

            m_Core = core;

            DockHandler.GetPersistStringCallback = PersistString;

            var col = eventView.Columns["Drawcall"]; eventView.Columns.SetVisibleIndex(col, -1);
            col = eventView.Columns["Duration"];     eventView.Columns.SetVisibleIndex(col, -1);

            UpdateDurationColumn();

            eventView.CellPainter.CellDataConverter = DataToString;

            findEventButton.Enabled = false;
            jumpEventButton.Enabled = false;
            timeDraws.Enabled = false;
            toggleBookmark.Enabled = false;
        }

        public CaptureDialog(Core core, OnCaptureMethod captureCallback, OnInjectMethod injectCallback)
        {
            InitializeComponent();

            exePath.Font =
                workDirPath.Font =
                cmdline.Font =
                pidList.Font =
                core.Config.PreferredFont;

            Icon = global::renderdocui.Properties.Resources.icon;

            vulkanLayerWarn.Visible = !Helpers.CheckVulkanLayerRegistration();

            var defaults = new CaptureSettings();
            defaults.Inject = false;

            m_CaptureCallback = captureCallback;
            m_InjectCallback = injectCallback;

            m_Core = core;

            workDirHint = true;
            workDirPath.ForeColor = SystemColors.GrayText;

            SetSettings(defaults);

            UpdateGlobalHook();
        }

        public DebugMessages(Core core)
        {
            InitializeComponent();

            Icon = global::renderdocui.Properties.Resources.icon;

            m_Core = core;
        }

        public SettingsDialog(Core c)
        {
            m_Core = c;

            InitializeComponent();

            Icon = global::renderdocui.Properties.Resources.icon;

            pagesTree.BeginUpdate();
            foreach (TabPage t in settingsTabs.TabPages)
            {
                pagesTree.Nodes.Add(new object[] { t.Text }).Tag = t;
            }
            pagesTree.EndUpdate();
            pagesTree.FocusedNode = pagesTree.Nodes[0];

            saveDirectory.Text = m_Core.Config.DefaultCaptureSaveDirectory;
            tempDirectory.Text = m_Core.Config.TemporaryCaptureDirectory;

            TextureViewer_ResetRange.Checked = m_Core.Config.TextureViewer_ResetRange;
            TextureViewer_PerTexSettings.Checked = m_Core.Config.TextureViewer_PerTexSettings;
            ShaderViewer_FriendlyNaming.Checked = m_Core.Config.ShaderViewer_FriendlyNaming;
            CheckUpdate_AllowChecks.Checked = m_Core.Config.CheckUpdate_AllowChecks;
            Font_PreferMonospaced.Checked = m_Core.Config.Font_PreferMonospaced;

            AlwaysReplayLocally.Checked = m_Core.Config.AlwaysReplayLocally;

            AllowGlobalHook.Checked = m_Core.Config.AllowGlobalHook;

            {
                Type type = m_Core.Config.EventBrowser_TimeUnit.GetType();

                EventBrowser_TimeUnit.Items.Clear();

                foreach (int v in type.GetEnumValues())
                {
                    EventBrowser_TimeUnit.Items.Add(PersistantConfig.UnitPrefix((PersistantConfig.TimeUnit)v));
                }
            }

            EventBrowser_TimeUnit.SelectedIndex = (int)m_Core.Config.EventBrowser_TimeUnit;
            EventBrowser_HideEmpty.Checked = m_Core.Config.EventBrowser_HideEmpty;
            EventBrowser_ApplyColours.Checked = m_Core.Config.EventBrowser_ApplyColours;
            EventBrowser_ColourEventRow.Checked = m_Core.Config.EventBrowser_ColourEventRow;

            // disable sub-checkbox
            EventBrowser_ColourEventRow.Enabled = EventBrowser_ApplyColours.Checked;

            initialising = true;

            Formatter_MinFigures.Value = m_Core.Config.Formatter_MinFigures;
            Formatter_MaxFigures.Value = m_Core.Config.Formatter_MaxFigures;
            Formatter_NegExp.Value = m_Core.Config.Formatter_NegExp;
            Formatter_PosExp.Value = m_Core.Config.Formatter_PosExp;

            initialising = false;
        }

        public StatisticsViewer(Core core)
        {
            InitializeComponent();

            Icon = global::renderdocui.Properties.Resources.icon;

            m_Core = core;

            statisticsLog.Font = new System.Drawing.Font("Consolas", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
        }

        public PythonShell(Core core)
        {
            InitializeComponent();

            if (SystemInformation.HighContrast)
            {
                toolStrip1.Renderer = new ToolStripSystemRenderer();
                toolStrip2.Renderer = new ToolStripSystemRenderer();
            }

            shellTable.Dock = DockStyle.Fill;
            scriptTable.Dock = DockStyle.Fill;

            scriptEditor = new ScintillaNET.Scintilla();
            ((System.ComponentModel.ISupportInitialize)(scriptEditor)).BeginInit();

            scriptEditor.Dock = System.Windows.Forms.DockStyle.Fill;
            scriptEditor.Location = new System.Drawing.Point(3, 3);
            scriptEditor.Name = "scripteditor";
            scriptEditor.Font = new Font("Consolas", 8.25F, FontStyle.Regular, GraphicsUnit.Point, 0);

            scriptEditor.Margins.Left = 4;
            scriptEditor.Margins.Margin0.Width = 30;
            scriptEditor.Margins.Margin1.Width = 0;
            scriptEditor.Margins.Margin2.Width = 16;

            scriptEditor.Markers[0].BackColor = System.Drawing.Color.LightCoral;

            scriptEditor.ConfigurationManager.Language = "python";

            ((System.ComponentModel.ISupportInitialize)(scriptEditor)).EndInit();

            scriptEditor.KeyDown += new KeyEventHandler(scriptEditor_KeyDown);
            scriptEditor.TextChanged += new EventHandler(scriptEditor_TextChanged);

            newScript.PerformClick();

            scriptEditor.Scrolling.HorizontalWidth = 1;

            const uint SCI_SETSCROLLWIDTHTRACKING = 2516;
            scriptEditor.NativeInterface.SendMessageDirect(SCI_SETSCROLLWIDTHTRACKING, true);

            scriptSplit.Panel1.Controls.Add(scriptEditor);

            m_Core = core;

            pythonengine = NewEngine();

            mode_Changed(shellMode, null);

            clearCmd_Click(null, null);

            EnableButtons(true);
        }

        public TextureViewer(Core core)
        {
            m_Core = core;

            InitializeComponent();

            Icon = global::renderdocui.Properties.Resources.icon;

            textureList.m_Core = core;
            textureList.GoIconClick += new EventHandler<GoIconClickEventArgs>(textureList_GoIconClick);

            UI_SetupToolstrips();
            UI_SetupDocks();
            UI_UpdateTextureDetails();
            statusLabel.Text = "";
            zoomOption.SelectedText = "";
            mipLevel.Enabled = false;
            sliceFace.Enabled = false;

            PixelPicked = false;

            mainLayout.Dock = DockStyle.Fill;

            render.Painting = true;
            pixelContext.Painting = true;

            saveTex.Enabled = false;

            DockHandler.GetPersistStringCallback = PersistString;

            renderContainer.MouseWheelHandler = render_MouseWheel;
            render.MouseWheel += render_MouseWheel;
            renderContainer.MouseDown += render_MouseClick;
            renderContainer.MouseMove += render_MouseMove;

            render.KeyHandler = render_KeyDown;

            rangeHistogram.RangeUpdated += new EventHandler<RangeHistogramEventArgs>(rangeHistogram_RangeUpdated);

            this.DoubleBuffered = true;

            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);

            channels.SelectedIndex = 0;

            FitToWindow = true;
            overlay.SelectedIndex = 0;
            m_Following = new Following(FollowType.RT_UAV, 0);

            texturefilter.SelectedIndex = 0;

            if (m_Core.LogLoaded)
                OnLogfileLoaded();
        }

        public APIInspector(Core core)
        {
            InitializeComponent();

            Icon = global::renderdocui.Properties.Resources.icon;

            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);

            m_Core = core;

            panelSplitter.Collapsed = true;
        }

        public DebugMessages(Core core)
        {
            InitializeComponent();

            Icon = global::renderdocui.Properties.Resources.icon;

            m_Core = core;

            messages.Font = core.Config.PreferredFont;

            RefreshMessageList();
        }

        public UpdateDialog(Core core)
        {
            InitializeComponent();

            doupdate.FlatStyle = FlatStyle.System;
            SendMessage(doupdate.Handle, BCM_SETSHIELD, 0, 0xFFFFFFFF);

            string[] response_split = core.Config.CheckUpdate_UpdateResponse.Split('\n');

            progressText.Text = "";
            progressBar.Visible = false;

            Text = updateVer.Text = String.Format("Update Available - v{0}", response_split[0]);
            m_NewVer = response_split[0];
            m_URL = response_split[1];
            int.TryParse(response_split[2], out m_Size);

            string notes = "";
            for(int i=3; i < response_split.Length; i++)
                notes += response_split[i] + Environment.NewLine;

            try
            {
                updateNotes.Rtf = notes.Trim();
            }
            catch (Exception)
            {
                // most likely invalid formatting, so fall back to a sensible default
                updateNotes.Rtf = @"{\rtf1\ansi\fs36\sa200\sl276\slmult1RenderDoc v" + m_NewVer + @" \fs16" +
                    @"\par A new version of RenderDoc is available and it's recommended that you update.}";
            }

            updateNotes.Select(0, 0);

            string curver = "?.?";

            try
            {
                curver = StaticExports.GetVersionString();
            }
            catch (System.Exception)
            {
                // probably StaticExports.GetVersionString is missing, which means an old
                // version is running
            }

            updateMetadata.Text = "v" + curver +
                Environment.NewLine + Environment.NewLine +
                String.Format("v{0}", response_split[0]) +
                Environment.NewLine + Environment.NewLine +
                String.Format("{0:0.00} MB", (float)m_Size/1024.0f/1024.0f);
        }