From 364b7392f881ae5aa17f73203dfc8152020d3bb4 Mon Sep 17 00:00:00 2001 From: konekoneko Date: Fri, 30 Dec 2011 09:11:21 +0900 Subject: [PATCH] =?utf8?q?SVN=E3=81=8B=E3=82=89=E7=A7=BB=E8=A1=8C=E3=81=97?= =?utf8?q?=E3=81=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit --- .gitignore | 3 + D2DBench.sln | 20 + D2DBench.suo | Bin 0 -> 17408 bytes D2DBench/ColorTableD2D.cs | 42 + D2DBench/ColorTableGDI.cs | 34 + D2DBench/D2DBench.csproj | 116 + D2DBench/Form1.Designer.cs | 216 + D2DBench/Form1.cs | 101 + D2DBench/Form1.resx | 120 + D2DBench/Form2.Designer.cs | 46 + D2DBench/Form2.cs | 15 + D2DBench/Form2.resx | 120 + D2DBench/GDI.cs | 322 + D2DBench/HWInfo.cs | 37 + D2DBench/IBench.cs | 13 + D2DBench/Method1.cs | 64 + D2DBench/Method2.cs | 61 + D2DBench/Method3.cs | 65 + D2DBench/Method4.cs | 88 + D2DBench/Method5.cs | 46 + D2DBench/Method6.cs | 48 + D2DBench/Method7.cs | 52 + D2DBench/Method8.cs | 55 + D2DBench/Program.cs | 21 + D2DBench/Properties/AssemblyInfo.cs | 36 + D2DBench/Properties/Resources.Designer.cs | 88 + D2DBench/Properties/Resources.resx | 130 + D2DBench/Properties/Settings.Designer.cs | 30 + D2DBench/Properties/Settings.settings | 7 + D2DBench/RenderAdapter.cs | 48 + D2DBench/Resources/Image1.bmp | Bin 0 -> 3382 bytes D2DBench/image.bmp | Bin 0 -> 196662 bytes Libs/SharpDX.D3DCompiler.dll | Bin 0 -> 37376 bytes Libs/SharpDX.D3DCompiler.xml | 3437 +++++++ Libs/SharpDX.DXGI.dll | Bin 0 -> 53248 bytes Libs/SharpDX.DXGI.xml | 2895 ++++++ Libs/SharpDX.Direct2D1.dll | Bin 0 -> 134144 bytes Libs/SharpDX.Direct2D1.xml | 11469 +++++++++++++++++++++ Libs/SharpDX.Direct3D10.dll | Bin 0 -> 139776 bytes Libs/SharpDX.Direct3D10.xml | 13207 ++++++++++++++++++++++++ Libs/SharpDX.Direct3D11.dll | Bin 0 -> 146432 bytes Libs/SharpDX.Direct3D11.xml | 15004 ++++++++++++++++++++++++++++ Libs/SharpDX.DirectSound.dll | Bin 0 -> 56320 bytes Libs/SharpDX.DirectSound.xml | 4816 +++++++++ Libs/SharpDX.Error.dll | Bin 0 -> 350720 bytes Libs/SharpDX.Error.xml | 43 + Libs/SharpDX.XAPO.dll | Bin 0 -> 20480 bytes Libs/SharpDX.XAPO.xml | 970 ++ Libs/SharpDX.XAudio2.dll | Bin 0 -> 29696 bytes Libs/SharpDX.XAudio2.xml | 2156 ++++ Libs/SharpDX.dll | Bin 0 -> 181760 bytes Libs/SharpDX.xml | 12234 +++++++++++++++++++++++ 52 files changed, 68275 insertions(+) create mode 100644 .gitignore create mode 100644 D2DBench.sln create mode 100644 D2DBench.suo create mode 100644 D2DBench/ColorTableD2D.cs create mode 100644 D2DBench/ColorTableGDI.cs create mode 100644 D2DBench/D2DBench.csproj create mode 100644 D2DBench/Form1.Designer.cs create mode 100644 D2DBench/Form1.cs create mode 100644 D2DBench/Form1.resx create mode 100644 D2DBench/Form2.Designer.cs create mode 100644 D2DBench/Form2.cs create mode 100644 D2DBench/Form2.resx create mode 100644 D2DBench/GDI.cs create mode 100644 D2DBench/HWInfo.cs create mode 100644 D2DBench/IBench.cs create mode 100644 D2DBench/Method1.cs create mode 100644 D2DBench/Method2.cs create mode 100644 D2DBench/Method3.cs create mode 100644 D2DBench/Method4.cs create mode 100644 D2DBench/Method5.cs create mode 100644 D2DBench/Method6.cs create mode 100644 D2DBench/Method7.cs create mode 100644 D2DBench/Method8.cs create mode 100644 D2DBench/Program.cs create mode 100644 D2DBench/Properties/AssemblyInfo.cs create mode 100644 D2DBench/Properties/Resources.Designer.cs create mode 100644 D2DBench/Properties/Resources.resx create mode 100644 D2DBench/Properties/Settings.Designer.cs create mode 100644 D2DBench/Properties/Settings.settings create mode 100644 D2DBench/RenderAdapter.cs create mode 100644 D2DBench/Resources/Image1.bmp create mode 100644 D2DBench/image.bmp create mode 100644 Libs/SharpDX.D3DCompiler.dll create mode 100644 Libs/SharpDX.D3DCompiler.xml create mode 100644 Libs/SharpDX.DXGI.dll create mode 100644 Libs/SharpDX.DXGI.xml create mode 100644 Libs/SharpDX.Direct2D1.dll create mode 100644 Libs/SharpDX.Direct2D1.xml create mode 100644 Libs/SharpDX.Direct3D10.dll create mode 100644 Libs/SharpDX.Direct3D10.xml create mode 100644 Libs/SharpDX.Direct3D11.dll create mode 100644 Libs/SharpDX.Direct3D11.xml create mode 100644 Libs/SharpDX.DirectSound.dll create mode 100644 Libs/SharpDX.DirectSound.xml create mode 100644 Libs/SharpDX.Error.dll create mode 100644 Libs/SharpDX.Error.xml create mode 100644 Libs/SharpDX.XAPO.dll create mode 100644 Libs/SharpDX.XAPO.xml create mode 100644 Libs/SharpDX.XAudio2.dll create mode 100644 Libs/SharpDX.XAudio2.xml create mode 100644 Libs/SharpDX.dll create mode 100644 Libs/SharpDX.xml diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..22ac948 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ + +/D2DBench/obj +/D2DBench/bin \ No newline at end of file diff --git a/D2DBench.sln b/D2DBench.sln new file mode 100644 index 0000000..e2c0b07 --- /dev/null +++ b/D2DBench.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "D2DBench", "D2DBench\D2DBench.csproj", "{F4B858B3-F78C-4127-A71E-A0B1630F3536}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x86 = Debug|x86 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {F4B858B3-F78C-4127-A71E-A0B1630F3536}.Debug|x86.ActiveCfg = Debug|x86 + {F4B858B3-F78C-4127-A71E-A0B1630F3536}.Debug|x86.Build.0 = Debug|x86 + {F4B858B3-F78C-4127-A71E-A0B1630F3536}.Release|x86.ActiveCfg = Release|x86 + {F4B858B3-F78C-4127-A71E-A0B1630F3536}.Release|x86.Build.0 = Release|x86 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/D2DBench.suo b/D2DBench.suo new file mode 100644 index 0000000000000000000000000000000000000000..073cb815e43d9e27e871df635d8a7ddceaf0f90f GIT binary patch literal 17408 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 literal 0 HcmV?d00001 diff --git a/D2DBench/ColorTableD2D.cs b/D2DBench/ColorTableD2D.cs new file mode 100644 index 0000000..3dec5cc --- /dev/null +++ b/D2DBench/ColorTableD2D.cs @@ -0,0 +1,42 @@ +using System; +using System.Drawing; +using System.Collections.Generic; +using SharpDX; +using SharpDX.Direct2D1; +using SharpDX.DirectWrite; + +using Factory = SharpDX.Direct2D1.Factory; + +namespace D2DBench +{ + class ColorTableD2D + { + List brushlist = new List(); + + public ColorTableD2D(WindowRenderTarget render) + { + foreach (KnownColor item in Enum.GetValues(typeof(KnownColor))) + { + var brush = new SolidColorBrush(render, Color.FromKnownColor(item)); + brushlist.Add(brush); + } + } + + public int Count + { + get { return this.brushlist.Count; } + } + + public SolidColorBrush this[int i] + { + get { return this.brushlist[i]; } + } + + public void Clear() + { + foreach (SolidColorBrush brush in this.brushlist) + brush.Dispose(); + this.brushlist.Clear(); + } + } +} diff --git a/D2DBench/ColorTableGDI.cs b/D2DBench/ColorTableGDI.cs new file mode 100644 index 0000000..c8c8fbb --- /dev/null +++ b/D2DBench/ColorTableGDI.cs @@ -0,0 +1,34 @@ +using System; +using System.Drawing; +using System.Collections.Generic; + +namespace D2DBench +{ + class ColorTableGDI + { + List colorlist = new List(); + + public ColorTableGDI() + { + foreach (KnownColor item in Enum.GetValues(typeof(KnownColor))) + { + this.colorlist.Add(Color.FromKnownColor(item)); + } + } + + public int Count + { + get { return this.colorlist.Count; } + } + + public Color this[int i] + { + get { return this.colorlist[i]; } + } + + public void Clear() + { + this.colorlist.Clear(); + } + } +} diff --git a/D2DBench/D2DBench.csproj b/D2DBench/D2DBench.csproj new file mode 100644 index 0000000..714fb43 --- /dev/null +++ b/D2DBench/D2DBench.csproj @@ -0,0 +1,116 @@ + + + + Debug + x86 + 8.0.30703 + 2.0 + {F4B858B3-F78C-4127-A71E-A0B1630F3536} + WinExe + Properties + D2DBench + D2DBench + v4.0 + Client + 512 + + + x86 + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + x86 + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + False + ..\Libs\SharpDX.dll + + + False + ..\Libs\SharpDX.Direct2D1.dll + + + False + ..\Libs\SharpDX.DXGI.dll + + + False + ..\Libs\SharpDX.Error.dll + + + + + + + + + + + Form + + + Form1.cs + + + Form + + + Form2.cs + + + + + + + + + + + + + + + + + + Form1.cs + + + Form2.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + True + + + + + + + + \ No newline at end of file diff --git a/D2DBench/Form1.Designer.cs b/D2DBench/Form1.Designer.cs new file mode 100644 index 0000000..05161f8 --- /dev/null +++ b/D2DBench/Form1.Designer.cs @@ -0,0 +1,216 @@ +namespace D2DBench +{ + partial class Form1 + { + ///

+ /// 必要なデザイナー変数です。 + /// + private System.ComponentModel.IContainer components = null; + + /// + /// 使用中のリソースをすべてクリーンアップします。 + /// + /// マネージ リソースが破棄される場合 true、破棄されない場合は false です。 + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows フォーム デザイナーで生成されたコード + + /// + /// デザイナー サポートに必要なメソッドです。このメソッドの内容を + /// コード エディターで変更しないでください。 + /// + private void InitializeComponent() + { + this.button1 = new System.Windows.Forms.Button(); + this.button4 = new System.Windows.Forms.Button(); + this.label5 = new System.Windows.Forms.Label(); + this.label6 = new System.Windows.Forms.Label(); + this.textBox4 = new System.Windows.Forms.TextBox(); + this.textBox5 = new System.Windows.Forms.TextBox(); + this.listView1 = new System.Windows.Forms.ListView(); + this.method = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.time = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.fillrate = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.label2 = new System.Windows.Forms.Label(); + this.comboBox1 = new System.Windows.Forms.ComboBox(); + this.checkBox1 = new System.Windows.Forms.CheckBox(); + this.checkBox2 = new System.Windows.Forms.CheckBox(); + this.SuspendLayout(); + // + // button1 + // + this.button1.Location = new System.Drawing.Point(57, 270); + this.button1.Name = "button1"; + this.button1.Size = new System.Drawing.Size(64, 23); + this.button1.TabIndex = 1; + this.button1.Text = "計測開始"; + this.button1.UseVisualStyleBackColor = true; + this.button1.Click += new System.EventHandler(this.button1_Click); + // + // button4 + // + this.button4.Location = new System.Drawing.Point(126, 270); + this.button4.Name = "button4"; + this.button4.Size = new System.Drawing.Size(76, 23); + this.button4.TabIndex = 11; + this.button4.Text = "結果をコピー"; + this.button4.UseVisualStyleBackColor = true; + this.button4.Click += new System.EventHandler(this.button4_Click); + // + // label5 + // + this.label5.AutoSize = true; + this.label5.Location = new System.Drawing.Point(10, 155); + this.label5.Name = "label5"; + this.label5.Size = new System.Drawing.Size(27, 14); + this.label5.TabIndex = 13; + this.label5.Text = "高さ"; + // + // label6 + // + this.label6.AutoSize = true; + this.label6.Location = new System.Drawing.Point(122, 155); + this.label6.Name = "label6"; + this.label6.Size = new System.Drawing.Size(19, 14); + this.label6.TabIndex = 15; + this.label6.Text = "幅"; + // + // textBox4 + // + this.textBox4.Location = new System.Drawing.Point(47, 152); + this.textBox4.Name = "textBox4"; + this.textBox4.Size = new System.Drawing.Size(62, 22); + this.textBox4.TabIndex = 16; + // + // textBox5 + // + this.textBox5.Location = new System.Drawing.Point(147, 151); + this.textBox5.Name = "textBox5"; + this.textBox5.Size = new System.Drawing.Size(62, 22); + this.textBox5.TabIndex = 17; + // + // listView1 + // + this.listView1.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] { + this.method, + this.time, + this.fillrate}); + this.listView1.LabelWrap = false; + this.listView1.Location = new System.Drawing.Point(13, 12); + this.listView1.Name = "listView1"; + this.listView1.Size = new System.Drawing.Size(199, 131); + this.listView1.TabIndex = 18; + this.listView1.UseCompatibleStateImageBehavior = false; + this.listView1.View = System.Windows.Forms.View.Details; + // + // method + // + this.method.Text = "項目"; + this.method.Width = 65; + // + // time + // + this.time.Text = "時間"; + this.time.Width = 85; + // + // fillrate + // + this.fillrate.Text = "フィルレート"; + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(9, 184); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(55, 14); + this.label2.TabIndex = 19; + this.label2.Text = "実行回数"; + // + // comboBox1 + // + this.comboBox1.FormattingEnabled = true; + this.comboBox1.Items.AddRange(new object[] { + "1000", + "2000", + "3000", + "4000", + "5000", + "6000", + "7000", + "8000", + "9000", + "10000"}); + this.comboBox1.Location = new System.Drawing.Point(57, 181); + this.comboBox1.Name = "comboBox1"; + this.comboBox1.Size = new System.Drawing.Size(104, 22); + this.comboBox1.TabIndex = 20; + // + // checkBox1 + // + this.checkBox1.AutoSize = true; + this.checkBox1.Location = new System.Drawing.Point(13, 214); + this.checkBox1.Name = "checkBox1"; + this.checkBox1.Size = new System.Drawing.Size(189, 18); + this.checkBox1.TabIndex = 21; + this.checkBox1.Text = "GDIで行う（未チェックだとDirect2D)"; + this.checkBox1.UseVisualStyleBackColor = true; + // + // checkBox2 + // + this.checkBox2.AutoSize = true; + this.checkBox2.Location = new System.Drawing.Point(13, 238); + this.checkBox2.Name = "checkBox2"; + this.checkBox2.Size = new System.Drawing.Size(219, 18); + this.checkBox2.TabIndex = 22; + this.checkBox2.Text = "アンチエイリアシングを行う(Direct2Dのみ）"; + this.checkBox2.UseVisualStyleBackColor = true; + // + // Form1 + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 14F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(230, 305); + this.Controls.Add(this.checkBox2); + this.Controls.Add(this.checkBox1); + this.Controls.Add(this.comboBox1); + this.Controls.Add(this.label2); + this.Controls.Add(this.listView1); + this.Controls.Add(this.textBox5); + this.Controls.Add(this.textBox4); + this.Controls.Add(this.label6); + this.Controls.Add(this.label5); + this.Controls.Add(this.button4); + this.Controls.Add(this.button1); + this.Name = "Form1"; + this.Text = "2Dベンチ"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Button button1; + private System.Windows.Forms.Button button4; + private System.Windows.Forms.Label label5; + private System.Windows.Forms.Label label6; + private System.Windows.Forms.TextBox textBox4; + private System.Windows.Forms.TextBox textBox5; + private System.Windows.Forms.ListView listView1; + private System.Windows.Forms.ColumnHeader method; + private System.Windows.Forms.ColumnHeader time; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.ComboBox comboBox1; + private System.Windows.Forms.CheckBox checkBox1; + private System.Windows.Forms.ColumnHeader fillrate; + private System.Windows.Forms.CheckBox checkBox2; + } +} + diff --git a/D2DBench/Form1.cs b/D2DBench/Form1.cs new file mode 100644 index 0000000..f6e0b36 --- /dev/null +++ b/D2DBench/Form1.cs @@ -0,0 +1,101 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Windows.Forms; +using System.Diagnostics; +using D2DBench.Properties; + +namespace D2DBench +{ + public partial class Form1 : Form + { + public Form1() + { + InitializeComponent(); + this.textBox4.Text = Screen.GetBounds(this).Size.Width.ToString(); + this.textBox5.Text = Screen.GetBounds(this).Size.Height.ToString(); + this.comboBox1.SelectedIndex = 0; + if (Environment.OSVersion.Version.Major <= 5) + { + this.checkBox1.Checked = true; + this.checkBox1.Enabled = false; + } + } + + public const int ExecuteCountPerOneset = 50; + + private void button1_Click(object sender, EventArgs e) + { + int maxcount = Int32.Parse(this.comboBox1.SelectedItem.ToString()); + + this.listView1.Items.Clear(); + + Form2 benchFrom = CreateBenchForm(); + + List methods = new List(); + + if (this.checkBox1.Checked == false) + { + methods.Add(new Method1()); + methods.Add(new Method2()); + methods.Add(new Method3()); + methods.Add(new Method4()); + } + else + { + methods.Add(new Method5()); + methods.Add(new Method6()); + methods.Add(new Method7()); + methods.Add(new Method8()); + } + + foreach (IBench method in methods) + { + method.Init(benchFrom,this.checkBox2.Checked); + + Stopwatch watch = new Stopwatch(); + watch.Start(); + for (int i = 0; i < maxcount; i++) + method.Exec(); + watch.Stop(); + + ListViewItem item = new ListViewItem(method.methodName); + item.SubItems.Add(string.Format(Resources.Result, watch.ElapsedMilliseconds)); + double fillrate = (double)method.fillAreaSize / watch.ElapsedMilliseconds * 1000 / 1024 / 1024 * maxcount; + item.SubItems.Add(string.Format(Resources.FillRate, Math.Floor(fillrate * 100) / 100)); + this.listView1.Items.Add(item); + + method.Dispose(); + } + + benchFrom.Close(); + } + + private Form2 CreateBenchForm() + { + Form2 benchFrom = new Form2(); + benchFrom.Location = new Point(0, 0); + benchFrom.ClientSize = new Size(Int16.Parse(this.textBox4.Text), Int16.Parse(this.textBox5.Text)); + benchFrom.Show(); + return benchFrom; + } + + private void button4_Click(object sender, EventArgs e) + { + StringBuilder result = new StringBuilder(); + result.AppendFormat("OS:{0}\r\n", Environment.OSVersion.VersionString); + result.AppendFormat("ウィンドウサイズ:{0}×{1}\r\n", this.textBox4.Text, this.textBox5.Text); + result.AppendFormat("実行回数:{0}\r\n", (string)this.comboBox1.SelectedItem); + result.AppendFormat("アンチエイリアシング:{0}\r\n", this.checkBox2.Checked.ToString()); + foreach (string proc in HWInfo.processorNames) + result.AppendFormat("CPU:{0}\r\n",proc); + foreach (string vga in HWInfo.vgaNames) + result.AppendFormat("Video Controller:{0}\r\n", vga); + foreach (ListViewItem item in this.listView1.Items) + result.AppendFormat("{0}:{1} {2}\r\n", item.Text, item.SubItems[1].Text,item.SubItems[2].Text); + Clipboard.SetText(result.ToString()); + } + + } +} diff --git a/D2DBench/Form1.resx b/D2DBench/Form1.resx new file mode 100644 index 0000000..29dcb1b --- /dev/null +++ b/D2DBench/Form1.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/D2DBench/Form2.Designer.cs b/D2DBench/Form2.Designer.cs new file mode 100644 index 0000000..3523906 --- /dev/null +++ b/D2DBench/Form2.Designer.cs @@ -0,0 +1,46 @@ +namespace D2DBench +{ + partial class Form2 + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.SuspendLayout(); + // + // Form2 + // + this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 14F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(284, 262); + this.Name = "Form2"; + this.Text = "Form2"; + this.ResumeLayout(false); + + } + + #endregion + } +} \ No newline at end of file diff --git a/D2DBench/Form2.cs b/D2DBench/Form2.cs new file mode 100644 index 0000000..134ba7c --- /dev/null +++ b/D2DBench/Form2.cs @@ -0,0 +1,15 @@ +using System; +using System.Drawing; +using System.Windows.Forms; +using System.Diagnostics; + +namespace D2DBench +{ + public partial class Form2 : Form + { + public Form2() + { + InitializeComponent(); + } + } +} diff --git a/D2DBench/Form2.resx b/D2DBench/Form2.resx new file mode 100644 index 0000000..29dcb1b --- /dev/null +++ b/D2DBench/Form2.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/D2DBench/GDI.cs b/D2DBench/GDI.cs new file mode 100644 index 0000000..e95d5b7 --- /dev/null +++ b/D2DBench/GDI.cs @@ -0,0 +1,322 @@ +using System; +using System.Drawing; +using System.Windows.Forms; +using System.Runtime.InteropServices; +using System.Security; + +namespace D2DBench +{ + class GDIBitmap + { + public IntPtr hbmp; + public Graphics bmpGrp; + public IntPtr bmpDC; + public GDIBitmap(IntPtr hbmp, Graphics bmpGrp, IntPtr bmpDC) + { + this.hbmp = hbmp; + this.bmpGrp = bmpGrp; + this.bmpDC = bmpDC; + } + } + class GDI : IDisposable + { + [StructLayout(LayoutKind.Sequential)] + struct SIZE + { + public int cx; + public int cy; + + public SIZE(int cx, int cy) + { + this.cx = cx; + this.cy = cy; + } + } + [StructLayout(LayoutKind.Sequential)] + struct RECT + { + public int left; + public int top; + public int right; + public int bottom; + + public RECT(int left, int top, int right, int bottom) + { + this.left = left; + this.top = top; + this.right = right; + this.bottom = bottom; + } + } + + [Flags] + enum ETOOptions : uint + { + ETO_NONE = 0, + ETO_CLIPPED = 0x4, + ETO_GLYPH_INDEX = 0x10, + ETO_IGNORELANGUAGE = 0x1000, + ETO_NUMERICSLATIN = 0x800, + ETO_NUMERICSLOCAL = 0x400, + ETO_OPAQUE = 0x2, + ETO_PDY = 0x2000, + ETO_RTLREADING = 0x800, + } + + [Flags] + enum PenStyle : int + { + PS_SOLID = 0, + PS_DASH = 1, + PS_DOT = 2, + PS_DASHDOT = 3, + PS_DASHDOTDOT = 4, + PS_NULL = 5, + PS_INSIDEFRAME = 6, + PS_USERSTYLE = 7, + PS_ALTERNATE = 8, + PS_STYLE_MASK = 0x0000000F, + PS_ENDCAP_ROUND = 0x00000000, + PS_ENDCAP_SQUARE = 0x00000100, + PS_ENDCAP_FLAT = 0x00000200, + PS_ENDCAP_MASK = 0x00000F00, + PS_JOIN_ROUND = 0x00000000, + PS_JOIN_BEVEL = 0x00001000, + PS_JOIN_MITER = 0x00002000, + PS_JOIN_MASK = 0x0000F000, + PS_COSMETIC = 0x00000000, + PS_GEOMETRIC = 0x00010000, + PS_TYPE_MASK = 0x000F0000 + }; + + [Flags] + enum FontWeight : int + { + FW_DONTCARE = 0, + FW_THIN = 100, + FW_EXTRALIGHT = 200, + FW_LIGHT = 300, + FW_NORMAL = 400, + FW_MEDIUM = 500, + FW_SEMIBOLD = 600, + FW_BOLD = 700, + FW_EXTRABOLD = 800, + FW_HEAVY = 900, + } + [Flags] + enum FontCharSet : uint + { + ANSI_CHARSET = 0, + DEFAULT_CHARSET = 1, + SYMBOL_CHARSET = 2, + SHIFTJIS_CHARSET = 128, + HANGEUL_CHARSET = 129, + HANGUL_CHARSET = 129, + GB2312_CHARSET = 134, + CHINESEBIG5_CHARSET = 136, + OEM_CHARSET = 255, + JOHAB_CHARSET = 130, + HEBREW_CHARSET = 177, + ARABIC_CHARSET = 178, + GREEK_CHARSET = 161, + TURKISH_CHARSET = 162, + VIETNAMESE_CHARSET = 163, + THAI_CHARSET = 222, + EASTEUROPE_CHARSET = 238, + RUSSIAN_CHARSET = 204, + MAC_CHARSET = 77, + BALTIC_CHARSET = 186, + } + [Flags] + enum FontPrecision : uint + { + OUT_DEFAULT_PRECIS = 0, + OUT_STRING_PRECIS = 1, + OUT_CHARACTER_PRECIS = 2, + OUT_STROKE_PRECIS = 3, + OUT_TT_PRECIS = 4, + OUT_DEVICE_PRECIS = 5, + OUT_RASTER_PRECIS = 6, + OUT_TT_ONLY_PRECIS = 7, + OUT_OUTLINE_PRECIS = 8, + OUT_SCREEN_OUTLINE_PRECIS = 9, + OUT_PS_ONLY_PRECIS = 10, + } + [Flags] + enum FontClipPrecision : uint + { + CLIP_DEFAULT_PRECIS = 0, + CLIP_CHARACTER_PRECIS = 1, + CLIP_STROKE_PRECIS = 2, + CLIP_MASK = 0xf, + CLIP_LH_ANGLES = (1 << 4), + CLIP_TT_ALWAYS = (2 << 4), + CLIP_DFA_DISABLE = (4 << 4), + CLIP_EMBEDDED = (8 << 4), + } + [Flags] + enum FontQuality : uint + { + DEFAULT_QUALITY = 0, + DRAFT_QUALITY = 1, + PROOF_QUALITY = 2, + NONANTIALIASED_QUALITY = 3, + ANTIALIASED_QUALITY = 4, + CLEARTYPE_QUALITY = 5, + CLEARTYPE_NATURAL_QUALITY = 6, + } + [Flags] + enum FontPitchAndFamily : uint + { + DEFAULT_PITCH = 0, + FIXED_PITCH = 1, + VARIABLE_PITCH = 2, + FF_DONTCARE = (0 << 4), + FF_ROMAN = (1 << 4), + FF_SWISS = (2 << 4), + FF_MODERN = (3 << 4), + FF_SCRIPT = (4 << 4), + FF_DECORATIVE = (5 << 4), + } + + [DllImport("gdi32.dll"), SuppressUnmanagedCodeSecurity] + static extern IntPtr CreateSolidBrush(uint crColor); + [DllImport("gdi32.dll"), SuppressUnmanagedCodeSecurity] + static extern uint SetTextColor(IntPtr hdc, int crColor); + [DllImport("gdi32.dll"), SuppressUnmanagedCodeSecurity] + static extern uint SetBkColor(IntPtr hdc, int crColor); + [DllImport("gdi32.dll"), SuppressUnmanagedCodeSecurity] + static extern IntPtr SelectObject(IntPtr hdc, IntPtr hgdiobj); + [DllImport("gdi32.dll"), SuppressUnmanagedCodeSecurity] + static extern bool DeleteObject(IntPtr hObject); + [DllImport("gdi32.dll", EntryPoint = "GetTextExtentExPointW"), SuppressUnmanagedCodeSecurity] + static extern bool GetTextExtentExPoint(IntPtr hdc, [MarshalAs(UnmanagedType.LPWStr)] string lpszStr, int cchString, int nMaxExtent, out int lpnFit, int[] alpDx, out SIZE lpSize); + [DllImport("gdi32.dll", EntryPoint = "ExtTextOutW"), SuppressUnmanagedCodeSecurity] + static extern bool ExtTextOut(IntPtr hdc, int X, int Y, uint fuOptions, [In] ref RECT lprc, [MarshalAs(UnmanagedType.LPWStr)] string lpString, uint cbCount, [In] int[] lpDx); + [DllImport("gdi32.dll"), SuppressUnmanagedCodeSecurity] + static extern bool LineTo(IntPtr hdc, int nXEnd, int nYEnd); + [DllImport("gdi32.dll"), SuppressUnmanagedCodeSecurity] + static extern bool MoveToEx(IntPtr hdc, int X, int Y, IntPtr lpPoint); + [DllImport("gdi32.dll"), SuppressUnmanagedCodeSecurity] + static extern IntPtr CreatePen(PenStyle fnPenStyle, int nWidth, uint crColor); + [DllImport("gdi32.dll"), SuppressUnmanagedCodeSecurity] + static extern IntPtr CreateFont(int nHeight, int nWidth, int nEscapement, int nOrientation, FontWeight fnWeight, uint fdwItalic, uint fdwUnderline, uint fdwStrikeOut, FontCharSet fdwCharSet, FontPrecision fdwOutputPrecision, FontClipPrecision fdwClipPrecision, FontQuality fdwQuality, FontPitchAndFamily fdwPitchAndFamily, string lpszFace); + [System.Runtime.InteropServices.DllImportAttribute("gdi32.dll")] + static extern int BitBlt( + IntPtr hdcDest, // handle to destination DC (device context) + int nXDest, // x-coord of destination upper-left corner + int nYDest, // y-coord of destination upper-left corner + int nWidth, // width of destination rectangle + int nHeight, // height of destination rectangle + IntPtr hdcSrc, // handle to source DC + int nXSrc, // x-coordinate of source upper-left corner + int nYSrc, // y-coordinate of source upper-left corner + System.Int32 dwRop // raster operation code + ); + [DllImport("gdi32.dll", EntryPoint = "CreateCompatibleDC")] + public static extern IntPtr CreateCompatibleDC(IntPtr hdc); + [DllImport("gdi32.dll", EntryPoint = "DeleteDC")] + public static extern IntPtr DeleteDC(IntPtr hdc); + [DllImport("gdi32.dll", EntryPoint = "CreateCompatibleBitmap")] + public static extern IntPtr CreateCompatibleBitmap(IntPtr hdc,int nWidth, int nHeight); + + Graphics frontgrp; + Rectangle ClientRect; + IntPtr frontdc,backdc,backbmp; + + public GDI(Control ctrl) + { + ClientRect = ctrl.ClientRectangle; + this.frontgrp = ctrl.CreateGraphics(); + this.frontdc = this.frontgrp.GetHdc(); + this.backbmp = CreateCompatibleBitmap(this.frontdc, ClientRect.Width, ClientRect.Height); + } + + public void Dispose() + { + DeleteObject(this.backbmp); + this.frontgrp.ReleaseHdc(this.frontdc); + this.frontgrp.Dispose(); + } + + public void BeginDraw() + { + this.backdc = CreateCompatibleDC(this.frontdc); + SelectObject(this.backdc, this.backbmp); + } + + public void EndDraw() + { + BitBlt(this.frontdc, 0, 0, ClientRect.Width, ClientRect.Height, this.backdc, 0, 0, 0xcc0020); + DeleteDC(this.backdc); + } + + public GDIBitmap LoadImage(Bitmap src) + { + IntPtr hbmp = src.GetHbitmap(); + Graphics bmpGrp = Graphics.FromImage(src); + IntPtr hsrc = bmpGrp.GetHdc(); + return new GDIBitmap(hbmp, bmpGrp, hsrc); + } + + public void UnloadImage(GDIBitmap bmp) + { + bmp.bmpGrp.ReleaseHdc(bmp.bmpDC); + DeleteObject(bmp.hbmp); + } + + public void DrawImage(Rectangle dst,GDIBitmap gbmp) + { + IntPtr hbmpold = SelectObject(gbmp.bmpDC, gbmp.hbmp); + + BitBlt(backdc, dst.X, dst.Y, dst.Width, dst.Height, gbmp.bmpDC, 0, 0, 0xcc0020); + + SelectObject(gbmp.bmpDC, hbmpold); + } + + public void FillRectangle(Rectangle rectangle,Color color) + { + int OldBackColor = (int)SetBkColor(backdc, ColorTranslator.ToWin32(color)); + RECT rect = new RECT(rectangle.X, rectangle.Y, rectangle.Right + 1, rectangle.Bottom + 1); + ExtTextOut(backdc, rect.left, rect.top, (uint)ETOOptions.ETO_OPAQUE, ref rect, string.Empty, (uint)0, null); + SetTextColor(backdc, OldBackColor); + } + + public void DrawLine(Point from,Point to, int LineHeight, Color ForeColor) + { + PenStyle style = PenStyle.PS_SOLID; + IntPtr pen = CreatePen(style, LineHeight, (uint)ColorTranslator.ToWin32(ForeColor)); + + IntPtr oldpen = SelectObject(backdc, pen); + + MoveToEx(backdc, from.X, from.Y, IntPtr.Zero); + LineTo(backdc, to.X, to.Y); + + DeleteObject(pen); + SelectObject(backdc, oldpen); + } + + public void DrawString(Font font,string str, Color ForeColor,int x,int y) + { + int ForeColorCode = ColorTranslator.ToWin32(ForeColor); + + IntPtr hfont = GetHFont(font); + IntPtr OldFont = SelectObject(backdc, hfont); + int OldForeColor = (int)SetTextColor(backdc, ForeColorCode); + + ETOOptions opt = ETOOptions.ETO_NONE; + RECT rect = new RECT(x, y, x + 100, y + 100); + ExtTextOut(backdc, x, y, (uint)opt, ref rect, str, (uint)str.Length, null); + + DeleteObject(hfont); + SelectObject(backdc, OldFont); + SetTextColor(backdc, OldForeColor); + } + + IntPtr GetHFont(Font font) + { + int height = -(int)(font.Size * 96.0F / 72.0F); + return CreateFont(height, 0, 0, 0, FontWeight.FW_NORMAL, 0, 0, 0, FontCharSet.DEFAULT_CHARSET, FontPrecision.OUT_DEFAULT_PRECIS, FontClipPrecision.CLIP_DEFAULT_PRECIS, FontQuality.DEFAULT_QUALITY, FontPitchAndFamily.DEFAULT_PITCH, font.Name); + } + } +} diff --git a/D2DBench/HWInfo.cs b/D2DBench/HWInfo.cs new file mode 100644 index 0000000..ec0c774 --- /dev/null +++ b/D2DBench/HWInfo.cs @@ -0,0 +1,37 @@ +using System; +using System.Collections.Generic; +using System.Management; + +namespace D2DBench +{ + class HWInfo + { + public static IEnumerable vgaNames + { + get + { + ManagementClass managementClass = new ManagementClass("Win32_VideoController"); + ManagementObjectCollection managementObj = managementClass.GetInstances(); + List vgaNames = new List(); + foreach (ManagementObject mo in managementObj) + { + yield return mo["Name"].ToString(); + } + } + } + + public static IEnumerable processorNames + { + get + { + ManagementClass managementClass = new ManagementClass("Win32_Processor"); + ManagementObjectCollection managementObj = managementClass.GetInstances(); + List processeorNames = new List(); + foreach (ManagementObject mo in managementObj) + { + yield return mo["Name"].ToString(); + } + } + } + } +} diff --git a/D2DBench/IBench.cs b/D2DBench/IBench.cs new file mode 100644 index 0000000..a5af8a6 --- /dev/null +++ b/D2DBench/IBench.cs @@ -0,0 +1,13 @@ +using System; +using System.Windows.Forms; + +namespace D2DBench +{ + interface IBench : IDisposable + { + int fillAreaSize { get; } + string methodName { get; } + void Init(Control ctrl,bool antialias); + void Exec(); + } +} diff --git a/D2DBench/Method1.cs b/D2DBench/Method1.cs new file mode 100644 index 0000000..047d6dc --- /dev/null +++ b/D2DBench/Method1.cs @@ -0,0 +1,64 @@ +using System; +using System.Drawing; +using System.Diagnostics; +using System.Windows.Forms; +using SharpDX; +using SharpDX.Direct2D1; +using SharpDX.DirectWrite; + +using D2D = SharpDX.Direct2D1; +using DW = SharpDX.DirectWrite; +using Drawing = System.Drawing; + +namespace D2DBench +{ + class Method1 : IBench + { + public int fillAreaSize { get { return 0; } } + public string methodName { get { return "D2D文字列"; } } + + D2D.Factory Factory2D; + DW.Factory FactoryDWrite; + WindowRenderTarget render; + TextFormat format; + TextLayout layout; + ColorTableD2D colors; + Drawing.Size ClientSize; + Random rnd; + const string showStr = "D2DBenchMark"; + + public void Init(Control ctrl, bool antialias) + { + ClientSize = ctrl.ClientSize; + Factory2D = new SharpDX.Direct2D1.Factory(); + FactoryDWrite = new SharpDX.DirectWrite.Factory(); + HwndRenderTargetProperties hwndprops = new HwndRenderTargetProperties { Hwnd = ctrl.Handle, PixelSize = ClientSize, PresentOptions = PresentOptions.Immediately }; + render = new WindowRenderTarget(Factory2D, new RenderTargetProperties(), hwndprops); + format = new TextFormat(FactoryDWrite, ctrl.Font.Name, ctrl.Font.Size * render.DotsPerInch.Width / 72.0f); + colors = new ColorTableD2D(render); + rnd = new Random(); + layout = new TextLayout(FactoryDWrite, showStr, format, ClientSize.Width, ClientSize.Height); + render.AntialiasMode = antialias ? AntialiasMode.PerPrimitive : AntialiasMode.Aliased; + } + + public void Exec() + { + render.BeginDraw(); + for (int i = 0; i < Form1.ExecuteCountPerOneset; i++) + { + render.DrawTextLayout(new Point(rnd.Next(ClientSize.Width), rnd.Next(ClientSize.Height)), layout, colors[rnd.Next(colors.Count - 1)]); + } + render.EndDraw(); + } + + public void Dispose() + { + colors.Clear(); + layout.Dispose(); + format.Dispose(); + render.Dispose(); + Factory2D.Dispose(); + FactoryDWrite.Dispose(); + } + } +} diff --git a/D2DBench/Method2.cs b/D2DBench/Method2.cs new file mode 100644 index 0000000..91b4d3f --- /dev/null +++ b/D2DBench/Method2.cs @@ -0,0 +1,61 @@ +using System; +using System.Drawing; +using System.Diagnostics; +using System.Windows.Forms; +using SharpDX; +using SharpDX.Direct2D1; +using SharpDX.DirectWrite; + +using D2D = SharpDX.Direct2D1; +using DW = SharpDX.DirectWrite; +using Drawing = System.Drawing; + +namespace D2DBench +{ + class Method2: IBench + { + public int fillAreaSize { get { return 0; } } + public string methodName { get { return "D2D線"; } } + + D2D.Factory Factory2D; + DW.Factory FactoryDWrite; + WindowRenderTarget render; + ColorTableD2D colors; + Drawing.Size ClientSize; + Random rnd; + const string showStr = "D2DBenchMark"; + + public void Init(Control ctrl, bool antialias) + { + ClientSize = ctrl.ClientSize; + Factory2D = new SharpDX.Direct2D1.Factory(); + FactoryDWrite = new SharpDX.DirectWrite.Factory(); + HwndRenderTargetProperties hwndprops = new HwndRenderTargetProperties { Hwnd = ctrl.Handle, PixelSize = ClientSize, PresentOptions = PresentOptions.Immediately }; + render = new WindowRenderTarget(Factory2D, new RenderTargetProperties(), hwndprops); + colors = new ColorTableD2D(render); + rnd = new Random(); + render.AntialiasMode = antialias ? AntialiasMode.PerPrimitive : AntialiasMode.Aliased; + } + + public void Exec() + { + render.BeginDraw(); + for (int i = 0; i < Form1.ExecuteCountPerOneset; i++) + { + var fore = colors[rnd.Next(colors.Count - 1)]; + Point from = new Point(rnd.Next(ClientSize.Width), rnd.Next(ClientSize.Height)); + Point to = new Point(rnd.Next(ClientSize.Width), rnd.Next(ClientSize.Height)); + render.DrawLine(from, to, fore, 1.0f); + } + render.EndDraw(); + } + + public void Dispose() + { + colors.Clear(); + render.Dispose(); + Factory2D.Dispose(); + FactoryDWrite.Dispose(); + } + } +} diff --git a/D2DBench/Method3.cs b/D2DBench/Method3.cs new file mode 100644 index 0000000..9079f91 --- /dev/null +++ b/D2DBench/Method3.cs @@ -0,0 +1,65 @@ +using System; +using System.Drawing; +using System.Diagnostics; +using System.Windows.Forms; +using SharpDX; +using SharpDX.Direct2D1; +using SharpDX.DirectWrite; + +using D2D = SharpDX.Direct2D1; +using DW = SharpDX.DirectWrite; +using Drawing = System.Drawing; + +namespace D2DBench +{ + class Method3 : IBench + { + public int fillAreaSize { get { return bmpSize.Width * bmpSize.Height * Form1.ExecuteCountPerOneset; } } + public string methodName { get { return "D2D塗りつぶし"; } } + + D2D.Factory Factory2D; + DW.Factory FactoryDWrite; + WindowRenderTarget render; + ColorTableD2D colors; + Drawing.Size ClientSize; + Random rnd; + Drawing.Size bmpSize = D2DBench.Properties.Resources.image.Size; + const string showStr = "D2DBenchMark"; + + public void Init(Control ctrl, bool antialias) + { + ClientSize = ctrl.ClientSize; + Factory2D = new SharpDX.Direct2D1.Factory(); + FactoryDWrite = new SharpDX.DirectWrite.Factory(); + HwndRenderTargetProperties hwndprops = new HwndRenderTargetProperties { Hwnd = ctrl.Handle, PixelSize = ClientSize, PresentOptions = PresentOptions.Immediately }; + render = new WindowRenderTarget(Factory2D, new RenderTargetProperties(), hwndprops); + colors = new ColorTableD2D(render); + rnd = new Random(); + render.AntialiasMode = antialias ? AntialiasMode.PerPrimitive : AntialiasMode.Aliased; + } + + public void Exec() + { + render.BeginDraw(); + for (int i = 0; i < 100; i++) + { + var fore = colors[rnd.Next(colors.Count - 1)]; + SharpDX.RectangleF rect = new SharpDX.RectangleF(); + rect.Left = rnd.Next(ClientSize.Width); + rect.Top = rnd.Next(ClientSize.Height); + rect.Right = rect.Left + bmpSize.Width; + rect.Bottom = rect.Right + bmpSize.Height; + render.FillRectangle(rect, fore); + } + render.EndDraw(); + } + + public void Dispose() + { + colors.Clear(); + render.Dispose(); + Factory2D.Dispose(); + FactoryDWrite.Dispose(); + } + } +} diff --git a/D2DBench/Method4.cs b/D2DBench/Method4.cs new file mode 100644 index 0000000..ddce4e0 --- /dev/null +++ b/D2DBench/Method4.cs @@ -0,0 +1,88 @@ +using System; +using System.Drawing; +using System.Drawing.Imaging; +using System.Diagnostics; +using System.Windows.Forms; +using D2DBench.Properties; +using SharpDX; +using SharpDX.Direct2D1; +using SharpDX.DirectWrite; +using System.Runtime.InteropServices; + +using D2D1 = SharpDX.Direct2D1; +using DW = SharpDX.DirectWrite; +using Drawing = System.Drawing; + +namespace D2DBench +{ + class Method4 : IBench + { + public int fillAreaSize { get { return bmpSize.Width * bmpSize.Height * Form1.ExecuteCountPerOneset; } } + public string methodName { get { return "D2DBitBlt"; } } + + D2D1.Factory Factory2D; + DW.Factory FactoryDWrite; + WindowRenderTarget render; + Drawing.Size ClientSize; + Random rnd; + const string showStr = "D2DBenchMark"; + Drawing.Size bmpSize; + D2D1.Bitmap bmp; + + public void Init(Control ctrl, bool antialias) + { + ClientSize = ctrl.ClientSize; + Factory2D = new SharpDX.Direct2D1.Factory(); + FactoryDWrite = new SharpDX.DirectWrite.Factory(); + HwndRenderTargetProperties hwndprops = new HwndRenderTargetProperties { Hwnd = ctrl.Handle, PixelSize = ClientSize, PresentOptions = PresentOptions.Immediately }; + render = new WindowRenderTarget(Factory2D, new RenderTargetProperties(), hwndprops); + bmpSize = Resources.image.Size; + bmp = Load(render, Resources.image); + rnd = new Random(); + render.AntialiasMode = antialias ? AntialiasMode.PerPrimitive : AntialiasMode.Aliased; + } + + public void Dispose() + { + bmp.Dispose(); + render.Dispose(); + Factory2D.Dispose(); + FactoryDWrite.Dispose(); + } + + public void Exec() + { + render.BeginDraw(); + for (int i = 0; i < Form1.ExecuteCountPerOneset; i++) + { + SharpDX.RectangleF rect = new SharpDX.RectangleF(); + rect.Left = rnd.Next(ClientSize.Width); + rect.Top = rnd.Next(ClientSize.Height); + rect.Right = rect.Left + bmpSize.Width; + rect.Bottom = rect.Top + bmpSize.Height; + render.DrawBitmap(bmp, rect, 1.0f, BitmapInterpolationMode.NearestNeighbor); + } + render.EndDraw(); + } + + D2D1.Bitmap Load(WindowRenderTarget render, Drawing.Bitmap srcBitmap) + { + var bitmapData = srcBitmap.LockBits( + new Drawing.Rectangle(0, 0, srcBitmap.Width, srcBitmap.Height), + System.Drawing.Imaging.ImageLockMode.ReadOnly, + System.Drawing.Imaging.PixelFormat.Format32bppPArgb); + + var stream = new DataStream(bitmapData.Scan0, bitmapData.Stride * bitmapData.Height, true, false); + + var properties = new BitmapProperties() + { + PixelFormat = new D2D1.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode.Premultiplied) + }; + var bitmap = new D2D1.Bitmap(render, srcBitmap.Size, stream, bitmapData.Stride, properties); + + srcBitmap.UnlockBits(bitmapData); + + return bitmap; + } + } +} diff --git a/D2DBench/Method5.cs b/D2DBench/Method5.cs new file mode 100644 index 0000000..99afb37 --- /dev/null +++ b/D2DBench/Method5.cs @@ -0,0 +1,46 @@ +using System; +using System.Drawing; +using System.Diagnostics; +using System.Windows.Forms; + +namespace D2DBench +{ + class Method5 : IBench + { + public int fillAreaSize { get { return 0; } } + public string methodName { get { return "GDI文字列"; } } + + GDI gdi; + ColorTableGDI colors; + Size ClientSize; + const string showStr = "D2DBenchMark"; + Font font; + + public void Init(Control ctrl, bool antialias) + { + ClientSize = ctrl.ClientSize; + gdi = new GDI(ctrl); + colors = new ColorTableGDI(); + font = ctrl.Font; + ctrl.Show(); + } + + public void Exec() + { + Random rnd = new Random(); + gdi.BeginDraw(); + for (int j = 0; j < Form1.ExecuteCountPerOneset; j++) + { + Color c = colors[rnd.Next(colors.Count - 1)]; + gdi.DrawString(font, showStr, c, rnd.Next(ClientSize.Width), rnd.Next(ClientSize.Height)); + } + gdi.EndDraw(); + } + + public void Dispose() + { + colors.Clear(); + gdi.Dispose(); + } + } +} diff --git a/D2DBench/Method6.cs b/D2DBench/Method6.cs new file mode 100644 index 0000000..e6c7783 --- /dev/null +++ b/D2DBench/Method6.cs @@ -0,0 +1,48 @@ +using System; +using System.Drawing; +using System.Diagnostics; +using System.Windows.Forms; + +namespace D2DBench +{ + class Method6: IBench + { + public int fillAreaSize { get { return 0; } } + public string methodName { get { return "GDI線"; } } + + GDI gdi; + ColorTableGDI colors; + Size ClientSize; + const string showStr = "D2DBenchMark"; + Font font; + + public void Init(Control ctrl, bool antialias) + { + ClientSize = ctrl.ClientSize; + gdi = new GDI(ctrl); + colors = new ColorTableGDI(); + font = ctrl.Font; + ctrl.Show(); + } + + public void Exec() + { + Random rnd = new Random(); + gdi.BeginDraw(); + for (int j = 0; j < Form1.ExecuteCountPerOneset; j++) + { + Color fore = colors[rnd.Next(colors.Count - 1)]; + Point from = new Point(rnd.Next(ClientSize.Width), rnd.Next(ClientSize.Height)); + Point to = new Point(rnd.Next(ClientSize.Width), rnd.Next(ClientSize.Height)); + gdi.DrawLine(from, to, 1, fore); + } + gdi.EndDraw(); + } + + public void Dispose() + { + colors.Clear(); + gdi.Dispose(); + } + } +} diff --git a/D2DBench/Method7.cs b/D2DBench/Method7.cs new file mode 100644 index 0000000..b9296ba --- /dev/null +++ b/D2DBench/Method7.cs @@ -0,0 +1,52 @@ +using System; +using System.Drawing; +using System.Diagnostics; +using System.Windows.Forms; + +namespace D2DBench +{ + class Method7 : IBench + { + public int fillAreaSize { get { return bmpSize.Width * bmpSize.Height * Form1.ExecuteCountPerOneset; } } + public string methodName { get { return "GDI塗りつぶし"; } } + + GDI gdi; + ColorTableGDI colors; + Size ClientSize; + const string showStr = "D2DBenchMark"; + Font font; + Size bmpSize = D2DBench.Properties.Resources.image.Size; + + public void Init(Control ctrl, bool antialias) + { + ClientSize = ctrl.ClientSize; + gdi = new GDI(ctrl); + colors = new ColorTableGDI(); + font = ctrl.Font; + ctrl.Show(); + } + + public void Exec() + { + Random rnd = new Random(); + gdi.BeginDraw(); + for (int j = 0; j < Form1.ExecuteCountPerOneset; j++) + { + Color fore = colors[rnd.Next(colors.Count - 1)]; + Rectangle rect = new Rectangle(); + rect.X = rnd.Next(ClientSize.Width); + rect.Y = rnd.Next(ClientSize.Height); + rect.Width = bmpSize.Width; + rect.Height = bmpSize.Height; + gdi.FillRectangle(rect, fore); + } + gdi.EndDraw(); + } + + public void Dispose() + { + colors.Clear(); + gdi.Dispose(); + } + } +} diff --git a/D2DBench/Method8.cs b/D2DBench/Method8.cs new file mode 100644 index 0000000..717b83e --- /dev/null +++ b/D2DBench/Method8.cs @@ -0,0 +1,55 @@ +using System; +using System.Drawing; +using System.Diagnostics; +using System.Windows.Forms; +using D2DBench.Properties; + +namespace D2DBench +{ + class Method8 : IBench + { + public int fillAreaSize { get { return bmpSize.Width * bmpSize.Height * Form1.ExecuteCountPerOneset; } } + public string methodName { get { return "GDIBitBlt"; } } + + GDI gdi; + ColorTableGDI colors; + Size ClientSize; + const string showStr = "D2DBenchMark"; + Font font; + Size bmpSize; + GDIBitmap bmp; + + public void Init(Control ctrl, bool antialias) + { + ClientSize = ctrl.ClientSize; + gdi = new GDI(ctrl); + colors = new ColorTableGDI(); + font = ctrl.Font; + bmpSize = Resources.image.Size; + bmp = gdi.LoadImage(Resources.image); + ctrl.Show(); + } + + public void Exec() + { + Random rnd = new Random(); + gdi.BeginDraw(); + for (int j = 0; j < Form1.ExecuteCountPerOneset; j++) + { + Rectangle rect = new Rectangle(); + rect.X = rnd.Next(ClientSize.Width); + rect.Y = rnd.Next(ClientSize.Height); + rect.Width = rect.X + bmpSize.Width; + rect.Height = rect.Y + bmpSize.Height; + gdi.DrawImage(rect, bmp); + } + gdi.EndDraw(); + } + + public void Dispose() + { + gdi.UnloadImage(bmp); + gdi.Dispose(); + } + } +} diff --git a/D2DBench/Program.cs b/D2DBench/Program.cs new file mode 100644 index 0000000..030070a --- /dev/null +++ b/D2DBench/Program.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Windows.Forms; + +namespace D2DBench +{ + static class Program + { + /// + /// アプリケーションのメイン エントリ ポイントです。 + /// + [STAThread] + static void Main() + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new Form1()); + } + } +} diff --git a/D2DBench/Properties/AssemblyInfo.cs b/D2DBench/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..0911b51 --- /dev/null +++ b/D2DBench/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// アセンブリに関する一般情報は以下の属性セットをとおして制御されます。 +// アセンブリに関連付けられている情報を変更するには、 +// これらの属性値を変更してください。 +[assembly: AssemblyTitle("D2DBench")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Microsoft")] +[assembly: AssemblyProduct("D2DBench")] +[assembly: AssemblyCopyright("Copyright © Microsoft 2011")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// ComVisible を false に設定すると、その型はこのアセンブリ内で COM コンポーネントから +// 参照不可能になります。COM からこのアセンブリ内の型にアクセスする場合は、 +// その型の ComVisible 属性を true に設定してください。 +[assembly: ComVisible(false)] + +// 次の GUID は、このプロジェクトが COM に公開される場合の、typelib の ID です +[assembly: Guid("77cce623-8436-48a6-8aab-64c1fdd79f86")] + +// アセンブリのバージョン情報は、以下の 4 つの値で構成されています: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// すべての値を指定するか、下のように '*' を使ってビルドおよびリビジョン番号を +// 既定値にすることができます: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.2.0.0")] +[assembly: AssemblyFileVersion("1.2.0.0")] diff --git a/D2DBench/Properties/Resources.Designer.cs b/D2DBench/Properties/Resources.Designer.cs new file mode 100644 index 0000000..60aafd2 --- /dev/null +++ b/D2DBench/Properties/Resources.Designer.cs @@ -0,0 +1,88 @@ +//------------------------------------------------------------------------------ +// +// このコードはツールによって生成されました。 +// ランタイム バージョン:4.0.30319.225 +// +// このファイルへの変更は、以下の状況下で不正な動作の原因になったり、 +// コードが再生成されるときに損失したりします。 +// +//------------------------------------------------------------------------------ + +namespace D2DBench.Properties { + using System; + + + /// + /// ローカライズされた文字列などを検索するための、厳密に型指定されたリソース クラスです。 + /// + // このクラスは StronglyTypedResourceBuilder クラスが ResGen + // または Visual Studio のようなツールを使用して自動生成されました。 + // メンバーを追加または削除するには、.ResX ファイルを編集して、/str オプションと共に + // ResGen を実行し直すか、または VS プロジェクトをビルドし直します。 + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// このクラスで使用されているキャッシュされた ResourceManager インスタンスを返します。 + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("D2DBench.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// 厳密に型指定されたこのリソース クラスを使用して、すべての検索リソースに対し、 + /// 現在のスレッドの CurrentUICulture プロパティをオーバーライドします。 + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// {0}MPixel/s に類似しているローカライズされた文字列を検索します。 + /// + internal static string FillRate { + get { + return ResourceManager.GetString("FillRate", resourceCulture); + } + } + + internal static System.Drawing.Bitmap image { + get { + object obj = ResourceManager.GetObject("image", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// {0}ms に類似しているローカライズされた文字列を検索します。 + /// + internal static string Result { + get { + return ResourceManager.GetString("Result", resourceCulture); + } + } + } +} diff --git a/D2DBench/Properties/Resources.resx b/D2DBench/Properties/Resources.resx new file mode 100644 index 0000000..20a3e64 --- /dev/null +++ b/D2DBench/Properties/Resources.resx @@ -0,0 +1,130 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + ..\image.bmp;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + {0}ms + + + {0}MPixel/s + + \ No newline at end of file diff --git a/D2DBench/Properties/Settings.Designer.cs b/D2DBench/Properties/Settings.Designer.cs new file mode 100644 index 0000000..c195fea --- /dev/null +++ b/D2DBench/Properties/Settings.Designer.cs @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.225 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace D2DBench.Properties +{ + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "10.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase + { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default + { + get + { + return defaultInstance; + } + } + } +} diff --git a/D2DBench/Properties/Settings.settings b/D2DBench/Properties/Settings.settings new file mode 100644 index 0000000..abf36c5 --- /dev/null +++ b/D2DBench/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/D2DBench/RenderAdapter.cs b/D2DBench/RenderAdapter.cs new file mode 100644 index 0000000..33cecff --- /dev/null +++ b/D2DBench/RenderAdapter.cs @@ -0,0 +1,48 @@ +using System; +using System.Drawing; +using System.Windows.Forms; + +namespace D2DBench +{ + class RenderAdapter : IDisposable + { + public RenderAdapter() + { + } + + public void BeginDraw() + { + throw new NotImplementedException(); + } + + public void Dispose() + { + throw new NotImplementedException(); + } + + public void DrawImage(System.Drawing.Rectangle dst, System.Drawing.Bitmap src) + { + throw new NotImplementedException(); + } + + public void DrawLine(IntPtr dc, System.Drawing.Point from, System.Drawing.Point to, int LineHeight, System.Drawing.Color ForeColor) + { + throw new NotImplementedException(); + } + + public void DrawString(IntPtr dc, System.Drawing.Font font, string str, System.Drawing.Color ForeColor, int x, int y) + { + throw new NotImplementedException(); + } + + public void EndDraw() + { + throw new NotImplementedException(); + } + + public void FillRectangle(IntPtr dc, System.Drawing.Rectangle rectangle, System.Drawing.Color color) + { + throw new NotImplementedException(); + } + } +} diff --git a/D2DBench/Resources/Image1.bmp b/D2DBench/Resources/Image1.bmp new file mode 100644 index 0000000000000000000000000000000000000000..55516c7aaa3591604865d4cd18379f8f650c3104 GIT binary patch literal 3382 zcmeIwA#&YN425B3CLjUbgJ57$uqM1+gO+lZkut%6E<(#F6wORPc)-i=r?4!c_Vwp; zZ3Fx2>gm_x54#?Zw`LE_etx;JyM1xL@%<_@PLnpcGPUluKQDjn-|L&12NJySLSxLr z;9wF7q0kt!G&lm>q)=$g*LR%^B!og^%$Qm^0tune7=F^=2qc6;W6U^h9D#&TXpDvN zo8~x1LMSw5m*!3e5<;OdyXkPr%u*^;D_frLmI06Zw(3st}a59h(3XRzqWFR3F8nf*xCj$wg(3oxIax#z*3XRz|Zzlr@q3r$RV$Z*g8j2NO iuBTlt#|(_)(Q$tsX9dm*oE11La8}@~z*&L+tOB3FDm>c& literal 0 HcmV?d00001 diff --git a/D2DBench/image.bmp b/D2DBench/image.bmp new file mode 100644 index 0000000000000000000000000000000000000000..a91c616fbe78a73145640f057e0891753ab4fde0 GIT binary patch literal 196662 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
=f-M4{y&~R{^zqN|9HCb+vD|L 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%0A^?rBKkVQ-#wV`; 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 literal 0 HcmV?d00001 diff --git a/Libs/SharpDX.D3DCompiler.dll b/Libs/SharpDX.D3DCompiler.dll new file mode 100644 index 0000000000000000000000000000000000000000..9d8fc929c30a6a55b6651f501140207db339b8f4 GIT binary patch literal 37376 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ⓈG2@>ElKmXNPAaO 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 + + + SharpDX.D3DCompiler + + + + + Values that indicate how the pipeline interprets geometry or hull shader input primitives. + + + The method returns a D3D_PRIMITIVE-typed value. + + D3D_PRIMITIVE + + + + The shader has not been initialized with an input primitive type. + + D3D_PRIMITIVE_UNDEFINED + + + + Interpret the input primitive as a point. + + D3D_PRIMITIVE_POINT + + + + Interpret the input primitive as a line. + + D3D_PRIMITIVE_LINE + + + + Interpret the input primitive as a triangle. + + D3D_PRIMITIVE_TRIANGLE + + + + Interpret the input primitive as a line with adjacency data. + + D3D_PRIMITIVE_LINE_ADJ + + + + Interpret the input primitive as a triangle with adjacency data. + + D3D_PRIMITIVE_TRIANGLE_ADJ + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_1_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_2_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_3_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_4_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_5_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_6_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_7_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_8_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_9_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_10_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_11_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_12_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_13_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_14_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_15_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_16_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_17_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_18_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_19_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_20_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_21_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_22_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_23_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_24_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_25_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_26_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_27_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_28_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_29_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_30_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_31_CONTROL_POINT_PATCH + + + + Interpret the input primitive as a control point patch. + + D3D_PRIMITIVE_32_CONTROL_POINT_PATCH + + + + Values that indicate the location of a shader #include file. + + + You pass a D3D_INCLUDE_TYPE-typed value to the IncludeType parameter in a call to the method to indicate the location of the #include file. + + D3D_INCLUDE_TYPE + + + + The local directory. + + D3D_INCLUDE_LOCAL + + + + The system directory. + + D3D_INCLUDE_SYSTEM + + + + Values that identify the class of a shader variable. + + + The class of a shader variable is not a programming class; the class identifies the variable class such as scalar, vector, object, and so on. D3D_SHADER_VARIABLE_CLASS-typed values are specified in the Class member of the structure. + + D3D_SHADER_VARIABLE_CLASS + + + + The shader variable is a scalar. + + D3D_SVC_SCALAR + + + + The shader variable is a vector. + + D3D_SVC_VECTOR + + + + The shader variable is a row-major matrix. + + D3D_SVC_MATRIX_ROWS + + + + The shader variable is a column-major matrix. + + D3D_SVC_MATRIX_COLUMNS + + + + The shader variable is an object. + + D3D_SVC_OBJECT + + + + The shader variable is a structure. + + D3D_SVC_STRUCT + + + + The shader variable is a class. + + D3D_SVC_INTERFACE_CLASS + + + + The shader variable is an interface. + + D3D_SVC_INTERFACE_POINTER + + + + Values that identify information about a shader variable. + + + A call to the method returns D3D_SHADER_VARIABLE_FLAGS values in the uFlags member of a structure. + + D3D_SHADER_VARIABLE_FLAGS + + + + Indicates that the registers assigned to this shader variable were explicitly declared in shader code (instead of automatically assigned by the compiler). + + D3D_SVF_USERPACKED + + + + Indicates that this variable is used by this shader. This value confirms that a particular shader variable (which can be common to many different shaders) is indeed used by a particular shader. + + D3D_SVF_USED + + + + Indicates that this variable is an interface. + + D3D_SVF_INTERFACE_POINTER + + + + Indicates that this variable is a parameter of an interface. + + D3D_SVF_INTERFACE_PARAMETER + + + + None. + + None + + + + Values that identify various data, texture, and buffer types that can be assigned to a shader variable. + + + A call to the method returns a D3D_SHADER_VARIABLE_TYPE value in the Type member of a structure. The types in a structured buffer describe the structure of the elements in the buffer. The layout of these types generally match their C++ struct counterparts. The following examples show structured buffers: + struct mystruct {float4 val; uint ind;}; RWStructuredBuffer<mystruct> rwbuf; + RWStructuredBuffer<float3> rwbuf2; + + + + D3D_SHADER_VARIABLE_TYPE + + + + The variable is a void reference. + + D3D_SVT_VOID + + + + The variable is a boolean. + + D3D_SVT_BOOL + + + + The variable is an integer. + + D3D_SVT_INT + + + + The variable is a floating-point number. + + D3D_SVT_FLOAT + + + + The variable is a string. + + D3D_SVT_STRING + + + + The variable is a texture. + + D3D_SVT_TEXTURE + + + + The variable is a 1D texture. + + D3D_SVT_TEXTURE1D + + + + The variable is a 2D texture. + + D3D_SVT_TEXTURE2D + + + + The variable is a 3D texture. + + D3D_SVT_TEXTURE3D + + + + The variable is a texture cube. + + D3D_SVT_TEXTURECUBE + + + + The variable is a sampler. + + D3D_SVT_SAMPLER + + + + The variable is a pixel shader. + + D3D_SVT_SAMPLER1D + + + + The variable is a vertex shader. + + D3D_SVT_SAMPLER2D + + + + The variable is an unsigned integer. + + D3D_SVT_SAMPLER3D + + + + The variable is an 8-bit unsigned integer. + + D3D_SVT_SAMPLERCUBE + + + + The variable is a geometry shader. + + D3D_SVT_PIXELSHADER + + + + The variable is a rasterizer-state object. + + D3D_SVT_VERTEXSHADER + + + + The variable is a depth-stencil-state object. + + D3D_SVT_PIXELFRAGMENT + + + + The variable is a blend-state object. + + D3D_SVT_VERTEXFRAGMENT + + + + The variable is a buffer. + + D3D_SVT_UINT + + + + The variable is a constant buffer. + + D3D_SVT_UINT8 + + + + The variable is a texture buffer. + + D3D_SVT_GEOMETRYSHADER + + + + The variable is a 1D-texture array. + + D3D_SVT_RASTERIZER + + + + The variable is a 2D-texture array. + + D3D_SVT_DEPTHSTENCIL + + + + The variable is a render-target view. + + D3D_SVT_BLEND + + + + The variable is a depth-stencil view. + + D3D_SVT_BUFFER + + + + The variable is a 2D-multisampled texture. + + D3D_SVT_CBUFFER + + + + The variable is a 2D-multisampled-texture array. + + D3D_SVT_TBUFFER + + + + The variable is a texture-cube array. + + D3D_SVT_TEXTURE1DARRAY + + + + The variable holds a compiled hull-shader binary. + + D3D_SVT_TEXTURE2DARRAY + + + + The variable holds a compiled domain-shader binary. + + D3D_SVT_RENDERTARGETVIEW + + + + The variable is an interface. + + D3D_SVT_DEPTHSTENCILVIEW + + + + The variable holds a compiled compute-shader binary. + + D3D_SVT_TEXTURE2DMS + + + + The variable is a double precision (64-bit) floating-point number. + + D3D_SVT_TEXTURE2DMSARRAY + + + + The variable is a 1D read-and-write texture. + + D3D_SVT_TEXTURECUBEARRAY + + + + The variable is an array of 1D read-and-write textures. + + D3D_SVT_HULLSHADER + + + + The variable is a 2D read-and-write texture. + + D3D_SVT_DOMAINSHADER + + + + The variable is an array of 2D read-and-write textures. + + D3D_SVT_INTERFACE_POINTER + + + + The variable is a 3D read-and-write texture. + + D3D_SVT_COMPUTESHADER + + + + The variable is a read-and-write buffer. + + D3D_SVT_DOUBLE + + + + The variable is a byte-address buffer. + + D3D_SVT_RWTEXTURE1D + + + + The variable is a read-and-write byte-address buffer. + + D3D_SVT_RWTEXTURE1DARRAY + + + + The variable is a structured buffer. For more information about structured buffer, see the Remarks section. + + D3D_SVT_RWTEXTURE2D + + + + The variable is a read-and-write structured buffer. + + D3D_SVT_RWTEXTURE2DARRAY + + + + The variable is an append structured buffer. + + D3D_SVT_RWTEXTURE3D + + + + The variable is a consume structured buffer. + + D3D_SVT_RWBUFFER + + + + The variable is a void reference. + + D3D_SVT_BYTEADDRESS_BUFFER + + + + The variable is a boolean. + + D3D_SVT_RWBYTEADDRESS_BUFFER + + + + The variable is an integer. + + D3D_SVT_STRUCTURED_BUFFER + + + + The variable is a floating-point number. + + D3D_SVT_RWSTRUCTURED_BUFFER + + + + The variable is a string. + + D3D_SVT_APPEND_STRUCTURED_BUFFER + + + + The variable is a texture. + + D3D_SVT_CONSUME_STRUCTURED_BUFFER + + + + Values that identify shader-input options. + + + D3D_SHADER_INPUT_FLAGS-typed values are specified in the uFlags member of the structure. + + D3D_SHADER_INPUT_FLAGS + + + + Assign a shader input to a register based on the register assignment in the HLSL code (instead of letting the compiler choose the register). + + D3D_SIF_USERPACKED + + + + Use a comparison sampler, which uses the {{SampleCmp (DirectX HLSL Texture Object)}} and {{SampleCmpLevelZero (DirectX HLSL Texture Object)}} sampling functions. + + D3D_SIF_COMPARISON_SAMPLER + + + + A 2-bit value for encoding texture components. + + D3D_SIF_TEXTURE_COMPONENT_0 + + + + A 2-bit value for encoding texture components. + + D3D_SIF_TEXTURE_COMPONENT_1 + + + + A 2-bit value for encoding texture components. + + D3D_SIF_TEXTURE_COMPONENTS + + + + None. + + None + + + + Values that identify resource types that can be bound to a shader and that are reflected as part of the resource description for the shader. + + + D3D_SHADER_INPUT_TYPE-typed values are specified in the Type member of the structure. + + D3D_SHADER_INPUT_TYPE + + + + The shader resource is a constant buffer. + + D3D_SIT_CBUFFER + + + + The shader resource is a texture buffer. + + D3D_SIT_TBUFFER + + + + The shader resource is a texture. + + D3D_SIT_TEXTURE + + + + The shader resource is a sampler. + + D3D_SIT_SAMPLER + + + + The shader resource is a read-and-write buffer. + + D3D_SIT_UAV_RWTYPED + + + + The shader resource is a structured buffer. For more information about structured buffer, see the Remarks section. + + D3D_SIT_STRUCTURED + + + + The shader resource is a read-and-write structured buffer. + + D3D_SIT_UAV_RWSTRUCTURED + + + + The shader resource is a byte-address buffer. + + D3D_SIT_BYTEADDRESS + + + + The shader resource is a read-and-write byte-address buffer. + + D3D_SIT_UAV_RWBYTEADDRESS + + + + The shader resource is an append-structured buffer. + + D3D_SIT_UAV_APPEND_STRUCTURED + + + + The shader resource is a consume-structured buffer. + + D3D_SIT_UAV_CONSUME_STRUCTURED + + + + The shader resource is a read-and-write structured buffer that uses the built-in counter to append or consume. + + D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER + + + + Values that identify the indended use of a constant-data buffer. + + + D3D_SHADER_CBUFFER_FLAGS-typed values are specified in the uFlags member of the structure. + + D3D_SHADER_CBUFFER_FLAGS + + + + Bind the constant buffer to an input slot defined in HLSL code (instead of letting the compiler choose the input slot). + + D3D_CBF_USERPACKED + + + + None. + + None + + + + Values that identify the intended use of constant-buffer data. + + D3D_CBUFFER_TYPE + + + + A buffer containing scalar constants. + + D3D_CT_CBUFFER + + + + A buffer containing texture data. + + D3D_CT_TBUFFER + + + + A buffer containing interface references. + + D3D_CT_INTERFACE_POINTERS + + + + A buffer containing binding information. + + D3D_CT_RESOURCE_BIND_INFO + + + + Values that identify shader parameters that use system-value semantics. + + + The D3D_NAME values identify shader parameters that have {{predefined system-value}} semantics. These values are used in a shader-signature description. For more information about shader-signature description, see . + + D3D_NAME + + + + This parameter does not use a predefined system-value semantic. + + D3D_NAME_UNDEFINED + + + + This parameter contains position data. + + D3D_NAME_POSITION + + + + This parameter contains clip-distance data. + + D3D_NAME_CLIP_DISTANCE + + + + This parameter contains cull-distance data. + + D3D_NAME_CULL_DISTANCE + + + + This parameter contains a render-target-array index. + + D3D_NAME_RENDER_TARGET_ARRAY_INDEX + + + + This parameter contains a viewport-array index. + + D3D_NAME_VIEWPORT_ARRAY_INDEX + + + + This parameter contains a vertex ID. + + D3D_NAME_VERTEX_ID + + + + This parameter contains a primitive ID. + + D3D_NAME_PRIMITIVE_ID + + + + This parameter contains an instance ID. + + D3D_NAME_INSTANCE_ID + + + + This parameter contains data that identifies whether or not the primitive faces the camera. + + D3D_NAME_IS_FRONT_FACE + + + + This parameter contains a sampler-array index. + + D3D_NAME_SAMPLE_INDEX + + + + This parameter contains one of four tessellation factors that correspond to the amount of parts that a quad patch is broken into along the given edge. This flag is used to tessellate a quad patch. + + D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR + + + + This parameter contains one of two tessellation factors that correspond to the amount of parts that a quad patch is broken into vertically and horizontally within the patch. This flag is used to tessellate a quad patch. + + D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR + + + + This parameter contains one of three tessellation factors that correspond to the amount of parts that a tri patch is broken into along the given edge. This flag is used to tessellate a tri patch. + + D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR + + + + This parameter contains the tessellation factor that corresponds to the amount of parts that a tri patch is broken into within the patch. This flag is used to tessellate a tri patch. + + D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR + + + + This parameter contains the tessellation factor that corresponds to the number of lines broken into within the patch. This flag is used to tessellate an isolines patch. + + D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR + + + + This parameter contains the tessellation factor that corresponds to the number of lines that are created within the patch. This flag is used to tessellate an isolines patch. + + D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR + + + + This parameter contains render-target data. + + D3D_NAME_TARGET + + + + This parameter contains depth data. + + D3D_NAME_DEPTH + + + + This parameter contains alpha-coverage data. + + D3D_NAME_COVERAGE + + + + This parameter signifies that the value is greater than or equal to a reference value. This flag is used to specify conservative depth for a pixel shader. + + D3D_NAME_DEPTH_GREATER_EQUAL + + + + This parameter signifies that the value is less than or equal to a reference value. This flag is used to specify conservative depth for a pixel shader. + + D3D_NAME_DEPTH_LESS_EQUAL + + + + Values that identify the return type of a resource. + + + A resource return type is specified in the ReturnType member of the structure. + + D3D_RESOURCE_RETURN_TYPE + + + + Return type is an unsigned integer value normalized to a value between 0 and 1. + + D3D_RETURN_TYPE_UNORM + + + + Return type is a signed integer value normalized to a value between -1 and 1. + + D3D_RETURN_TYPE_SNORM + + + + Return type is a signed integer. + + D3D_RETURN_TYPE_SINT + + + + Return type is an unsigned integer. + + D3D_RETURN_TYPE_UINT + + + + Return type is a floating-point number. + + D3D_RETURN_TYPE_FLOAT + + + + Return type is unknown. + + D3D_RETURN_TYPE_MIXED + + + + Return type is a double-precision value. + + D3D_RETURN_TYPE_DOUBLE + + + + Return type is a multiple-dword type, such as a double or uint64, and the component is continued from the previous component that was declared. The first component represents the lower bits. + + D3D_RETURN_TYPE_CONTINUED + + + + Values that identify the data types that can be stored in a register. + + + A register component type is specified in the ComponentType member of the structure. + + D3D_REGISTER_COMPONENT_TYPE + + + + The data type is unknown. + + D3D_REGISTER_COMPONENT_UNKNOWN + + + + 32-bit unsigned integer. + + D3D_REGISTER_COMPONENT_UINT32 + + + + 32-bit signed integer. + + D3D_REGISTER_COMPONENT_SINT32 + + + + 32-bit floating-point number. + + D3D_REGISTER_COMPONENT_FLOAT32 + + + + Values that identify domain options for tessellator data. + + + The data domain defines the type of data. This enumeration is used by . + + D3D_TESSELLATOR_DOMAIN + + + + The data type is undefined. + + D3D_TESSELLATOR_DOMAIN_UNDEFINED + + + + Isoline data. + + D3D_TESSELLATOR_DOMAIN_ISOLINE + + + + Triangle data. + + D3D_TESSELLATOR_DOMAIN_TRI + + + + Quad data. + + D3D_TESSELLATOR_DOMAIN_QUAD + + + + Values that identify partitioning options. + + + During tessellation, the partition option helps to determine how the algorithm chooses the next partition value; this enumeration is used by . + + D3D_TESSELLATOR_PARTITIONING + + + + The partitioning type is undefined. + + D3D_TESSELLATOR_PARTITIONING_UNDEFINED + + + + Partition with integers only. + + D3D_TESSELLATOR_PARTITIONING_INTEGER + + + + Partition with a power-of-two number only. + + D3D_TESSELLATOR_PARTITIONING_POW2 + + + + Partition with an odd, fractional number. + + D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD + + + + Partition with an even, fractional number. + + D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN + + + + Values that identify output primitive types. + + + The output primitive type determines how the tessellator output data is organized; this enumeration is used by . + + D3D_TESSELLATOR_OUTPUT_PRIMITIVE + + + + The output primitive type is undefined. + + D3D_TESSELLATOR_OUTPUT_UNDEFINED + + + + The output primitive type is a point. + + D3D_TESSELLATOR_OUTPUT_POINT + + + + The output primitive type is a line. + + D3D_TESSELLATOR_OUTPUT_LINE + + + + The output primitive type is a clockwise triangle. + + D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW + + + + The output primitive type is a counter clockwise triangle. + + D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW + + + + Indicates shader type. + + D3D11_SHADER_VERSION_TYPE + + + + Pixel shader. + + D3D11_SHVER_PIXEL_SHADER + + + + Vertex shader. + + D3D11_SHVER_VERTEX_SHADER + + + + Geometry shader. + + D3D11_SHVER_GEOMETRY_SHADER + + + + Hull shader. + + D3D11_SHVER_HULL_SHADER + + + + Domain shader. + + D3D11_SHVER_DOMAIN_SHADER + + + + Compute shader. + + D3D11_SHVER_COMPUTE_SHADER + + + + Strip flag options. + + + These flags are used by . + + D3DCOMPILER_STRIP_FLAGS + + + + Remove reflection data. + + D3DCOMPILER_STRIP_REFLECTION_DATA + + + + Remove debug information. + + D3DCOMPILER_STRIP_DEBUG_INFO + + + + Remove test blob data. + + D3DCOMPILER_STRIP_TEST_BLOBS + + + + None. + + None + + + + Values that identify parts of the content of an arbitrary length data buffer. + + + These values are passed to the function. + + D3D_BLOB_PART + + + + The blob part is an input signature. + + D3D_BLOB_INPUT_SIGNATURE_BLOB + + + + The blob part is an output signature. + + D3D_BLOB_OUTPUT_SIGNATURE_BLOB + + + + The blob part is an input and output signature. + + D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB + + + + The blob part is a patch constant signature. + + D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB + + + + The blob part is all signature. + + D3D_BLOB_ALL_SIGNATURE_BLOB + + + + The blob part is debug information. + + D3D_BLOB_DEBUG_INFO + + + + The blob part is a legacy shader. + + D3D_BLOB_LEGACY_SHADER + + + + The blob part is an XNA prepass shader. + + D3D_BLOB_XNA_PREPASS_SHADER + + + + The blob part is an XNA shader. + + D3D_BLOB_XNA_SHADER + + + + The blob part is a test alternate shader. Note??This value identifies a test part and is only produced by special compiler versions. Therefore, this part type is typically not present in shaders. + + D3D_BLOB_TEST_ALTERNATE_SHADER + + + + The blob part is test compilation details. Note??This value identifies a test part and is only produced by special compiler versions. Therefore, this part type is typically not present in shaders. + + D3D_BLOB_TEST_COMPILE_DETAILS + + + + The blob part is test compilation performance. Note??This value identifies a test part and is only produced by special compiler versions. Therefore, this part type is typically not present in shaders. + + D3D_BLOB_TEST_COMPILE_PERF + + + + No documentation. + + D3DCOMPILE_SHADER_FLAGS + + + + No documentation. + + D3DCOMPILE_DEBUG + + + + No documentation. + + D3DCOMPILE_SKIP_VALIDATION + + + + No documentation. + + D3DCOMPILE_SKIP_OPTIMIZATION + + + + No documentation. + + D3DCOMPILE_PACK_MATRIX_ROW_MAJOR + + + + No documentation. + + D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR + + + + No documentation. + + D3DCOMPILE_PARTIAL_PRECISION + + + + No documentation. + + D3DCOMPILE_FORCE_VS_SOFTWARE_NO_OPT + + + + No documentation. + + D3DCOMPILE_FORCE_PS_SOFTWARE_NO_OPT + + + + No documentation. + + D3DCOMPILE_NO_PRESHADER + + + + No documentation. + + D3DCOMPILE_AVOID_FLOW_CONTROL + + + + No documentation. + + D3DCOMPILE_PREFER_FLOW_CONTROL + + + + No documentation. + + D3DCOMPILE_ENABLE_STRICTNESS + + + + No documentation. + + D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY + + + + No documentation. + + D3DCOMPILE_IEEE_STRICTNESS + + + + No documentation. + + D3DCOMPILE_OPTIMIZATION_LEVEL0 + + + + No documentation. + + D3DCOMPILE_OPTIMIZATION_LEVEL1 + + + + No documentation. + + D3DCOMPILE_OPTIMIZATION_LEVEL2 + + + + No documentation. + + D3DCOMPILE_OPTIMIZATION_LEVEL3 + + + + No documentation. + + D3DCOMPILE_RESERVED16 + + + + No documentation. + + D3DCOMPILE_RESERVED17 + + + + No documentation. + + D3DCOMPILE_WARNINGS_ARE_ERRORS + + + + None. + + None + + + + No documentation. + + D3DCOMPILE_EFFECT_FLAGS + + + + No documentation. + + D3DCOMPILE_EFFECT_CHILD_EFFECT + + + + No documentation. + + D3DCOMPILE_EFFECT_ALLOW_SLOW_OPS + + + + None. + + None + + + + No documentation. + + D3DCOMPILE_DISASM_FLAGS + + + + No documentation. + + D3D_DISASM_ENABLE_COLOR_CODE + + + + No documentation. + + D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS + + + + No documentation. + + D3D_DISASM_ENABLE_INSTRUCTION_NUMBERING + + + + No documentation. + + D3D_DISASM_ENABLE_INSTRUCTION_CYCLE + + + + No documentation. + + D3D_DISASM_DISABLE_DEBUG_INFO + + + + None. + + None + + + + D3D Functions. + + + + + Load DLLs and bind functions + + + + + Compile HLSL code into bytecode for a given target. + + A reference to uncompiled shader data; either ASCII HLSL code or a compiled effect. + Length of pSrcData. + Optional. The name of the shader file. Use either this or pSrcData. + Optional. An array of NULL-terminated macro definitions (see ). + Optional. A reference to an for handling include files. Setting this to NULL will cause a compile error if a shader contains a #include. + The name of the shader entry point function. + The shader target or set of shader features to compile against. + Shader {{compile options}}. + Effect {{compile options}}. When you compile a shader and not an effect file, D3DCompile ignores Flags2; therefore, you can set Flags2 to zero. + The address of a that contains the compiled code. + Optional. A reference to an that contains compiler error messages, or NULL if there were no errors. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DCompile([In, Buffer] const void* pSrcData,[In] SIZE_T SrcDataSize,[In, Optional] const char* pSourceName,[In, Buffer, Optional] const D3D_SHADER_MACRO* pDefines,[In, Optional] ID3DInclude* pInclude,[In] const char* pEntrypoint,[In] const char* pTarget,[In] D3DCOMPILE_SHADER_FLAGS Flags1,[In] D3DCOMPILE_EFFECT_FLAGS Flags2,[Out] ID3DBlob** ppCode,[Out, Optional] ID3DBlob** ppErrorMsgs) + + + + Preprocesses uncompiled HLSL code. + + + D3DPreprocess outputs {{#line}} directives and preserves line numbering of source input so that output line numbering can be properly related to the input source. + + A reference to uncompiled shader data; either ASCII HLSL code or a compiled effect. + Length of pSrcData. + Optional. The name of the file that contains the uncompiled HLSL code. + Optional. An array of NULL-terminated macro definitions (see ). + Optional. A reference to an for handling include files. Setting this to NULL will cause a compile error if a shader contains a #include. + The address of a that contains the compiled code. + Optional. A reference to an that contains compiler error messages, or NULL if there were no errors. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DPreprocess([In, Buffer] const void* pSrcData,[In] SIZE_T SrcDataSize,[In, Optional] const char* pSourceName,[In, Buffer, Optional] const D3D_SHADER_MACRO* pDefines,[In, Optional] ID3DInclude* pInclude,[Out] ID3DBlob** ppCodeText,[Out, Optional] ID3DBlob** ppErrorMsgs) + + + + Gets shader debug information. + + + Debug information is embedded in the body of the shader after calling . + + A reference to source data; either uncompiled or compiled HLSL code. + Length of pSrcData. + Optional. A reference to an that contains debug information. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DGetDebugInfo([In, Buffer] const void* pSrcData,[In] SIZE_T SrcDataSize,[Out] ID3DBlob** ppDebugInfo) + + + + Gets a reference to a reflection interface. + + + Shader code contains metadata that can be inspected using the reflection APIs. The following code illustrates retrieving a ID3D11ShaderReflection Interface from a shader. + pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(), pPixelShaderBuffer->GetBufferSize(), g_pPSClassLinkage, &g_pPixelShader ); ID3D11ShaderReflection* pReflector = NULL; + D3DReflect( pPixelShaderBuffer->GetBufferPointer(), pPixelShaderBuffer->GetBufferSize(), IID_ID3D11ShaderReflection, (void**) &pReflector); + + + A reference to source data as compiled HLSL code. + Length of pSrcData. + The reference GUID of the COM interface to use. For example, IID_ID3D11ShaderReflection or IID_ID3D10ShaderReflection. + A reference to a reflection interface. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DReflect([In, Buffer] const void* pSrcData,[In] SIZE_T SrcDataSize,[In] GUID* pInterface,[Out] void** ppReflector) + + + + Disassembles compiled HLSL code. + + A reference to source data as compiled HLSL code. + Length of pSrcData. + Flags affecting the behavior of D3DDisassemble. Flags can be a combination of zero or more of the following values. FlagDescription D3D_DISASM_ENABLE_COLOR_CODEEnable the output of color codes. D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTSEnable the output of default values. D3D_DISASM_ENABLE_INSTRUCTION_NUMBERINGEnable instruction numbering. D3D_DISASM_ENABLE_INSTRUCTION_CYCLENo effect. ? + Optional. + Optional. A reference to an that contains assembly text. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DDisassemble([In, Buffer] const void* pSrcData,[In] SIZE_T SrcDataSize,[In] D3DCOMPILE_DISASM_FLAGS Flags,[In, Optional] const char* szComments,[Out] ID3DBlob** ppDisassembly) + + + + Disassembles compiled HLSL code from a Direct3D10 effect. + + A reference to source data as compiled HLSL code. + Shader {{compile options}}. + Optional. A reference to an that contains disassembly text. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DDisassemble10Effect([In] ID3D10Effect* pEffect,[In] int Flags,[Out] ID3DBlob** ppDisassembly) + + + + Gets the input signature from a compilation result. + + A reference to source data as compiled HLSL code. + Length of pSrcData. + Optional. A reference to an that contains a compiled shader. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DGetInputSignatureBlob([In, Buffer] const void* pSrcData,[In] SIZE_T SrcDataSize,[Out] ID3DBlob** ppSignatureBlob) + + + + Gets the output signature from a compilation result. + + A reference to source data as compiled HLSL code. + Length of pSrcData. + Optional. A reference to an that contains a compiled shader. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DGetOutputSignatureBlob([In, Buffer] const void* pSrcData,[In] SIZE_T SrcDataSize,[Out] ID3DBlob** ppSignatureBlob) + + + + Gets the input and output signatures from a compilation result. + + A reference to source data as compiled HLSL code. + Length of pSrcData. + Optional. A reference to an that contains a compiled shader. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DGetInputAndOutputSignatureBlob([In, Buffer] const void* pSrcData,[In] SIZE_T SrcDataSize,[Out] ID3DBlob** ppSignatureBlob) + + + + Removes blobs from a compilation result. + + A reference to source data as compiled HLSL code. + Length of pSrcData. + Strip flag options, represented by . + Optional. A reference to an that contains compiler error messages, or NULL if there were no errors. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DStripShader([In, Buffer] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In] D3DCOMPILER_STRIP_FLAGS uStripFlags,[Out] ID3DBlob** ppStrippedBlob) + + + + Retrieves a specific part from a compilation result. + + + D3DGetBlobPart retrieves the part of a blob (arbitrary length data buffer) that contains the type of data that the Part parameter specifies. + + A reference to uncompiled shader data; either ASCII HLSL code or a compiled effect. + Length of uncompiled shader data that pSrcData points to. + A -typed value that specifies the part of the buffer to retrieve. + Flags that indicate how to retrieve the blob part. Currently, no flags are defined. + The address of a reference to the interface that is used to retrieve the specified part of the buffer. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DGetBlobPart([In, Buffer] const void* pSrcData,[In] SIZE_T SrcDataSize,[In] D3D_BLOB_PART Part,[In] int Flags,[Out] ID3DBlob** ppPart) + + + + Compresses a set of shaders into a more compact form. + + The number of shaders to compress. + An array of structures that describe the set of shaders to compress. + Flags that indicate how to compress the shaders. Currently, only the D3D_COMPRESS_SHADER_KEEP_ALL_PARTS (0x00000001) flag is defined. + The address of a reference to the interface that is used to retrieve the compressed shader data. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DCompressShaders([In] int uNumShaders,[In, Buffer] D3D_SHADER_DATA* pShaderData,[In] int uFlags,[Out] ID3DBlob** ppCompressedData) + + + + Decompresses one or more shaders from a compressed set. + + A reference to uncompiled shader data; either ASCII HLSL code or a compiled effect. + Length of uncompiled shader data that pSrcData points to. + The number of shaders to decompress. + The index of the first shader to decompress. + An array of indexes that represent the shaders to decompress. + Flags that indicate how to decompress. Currently, no flags are defined. + The address of a reference to the interface that is used to retrieve the decompressed shader data. + A reference to a variable that receives the total number of shaders that D3DDecompressShaders decompressed. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DDecompressShaders([In, Buffer] const void* pSrcData,[In] SIZE_T SrcDataSize,[In] int uNumShaders,[In] int uStartIndex,[In, Buffer, Optional] int* pIndices,[In] int uFlags,[Out, Buffer] ID3DBlob** ppShaders,[Out, Optional] int* pTotalShaders) + + + + An include interface allows an application to create user-overridable methods for opening and closing files when loading an effect from memory. + + ID3DInclude + + + + A user-implemented method for opening and reading the contents of a shader #include file. + + A -typed value that indicates the location of the #include file. + Name of the #include file. + Pointer to the container that includes the #include file. + Stream that is associated with fileName to be read. This reference remains valid until is called. + HRESULT Open([None] D3D_INCLUDE_TYPE IncludeType,[None] const char* pFileName,[None] LPCVOID pParentData,[None] LPCVOID* ppData,[None] UINT* pBytes) + + + + A user-implemented method for closing a shader #include file. + + + If was successful, Close is guaranteed to be called before the API using the interface returns. + + This is a reference that was returned by the corresponding call. + HRESULT Close([None] LPCVOID pData) + + + + This shader-reflection interface provides access to variable type. + + ID3D11ShaderReflectionType + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the description of a shader-reflection-variable type. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A reference to a shader-type description (see ). + Returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11ShaderReflectionType::GetDesc([Out] D3D11_SHADER_TYPE_DESC* pDesc) + + + + Get a shader-reflection-variable type by index. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + Zero-based index. + A reference to a . + ID3D11ShaderReflectionType* ID3D11ShaderReflectionType::GetMemberTypeByIndex([In] int Index) + + + + Get a shader-reflection-variable type by name. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + Member name. + A reference to a . + ID3D11ShaderReflectionType* ID3D11ShaderReflectionType::GetMemberTypeByName([In] const char* Name) + + + + Get a shader-reflection-variable type. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + Zero-based index. + The variable type. + const char* ID3D11ShaderReflectionType::GetMemberTypeName([In] int Index) + + + + Indicates whether two references have the same underlying type. + + + IsEqual indicates whether the sources of the references have the same underlying type. For example, if two ID3D11ShaderReflectionType Interface references were retrieved from variables, IsEqual can be used to see if the variables have the same type. This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A reference to a . + Returns S_OK if the references have the same underlying type; otherwise returns S_FALSE. + HRESULT ID3D11ShaderReflectionType::IsEqual([In] ID3D11ShaderReflectionType* pType) + + + + Gets the base class of a class. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + Returns a reference to a containing the base class type. Returns NULL if the class does not have a base class. + ID3D11ShaderReflectionType* ID3D11ShaderReflectionType::GetSubType() + + + + Gets an interface containing the variable base class type. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + Returns A reference to a . + ID3D11ShaderReflectionType* ID3D11ShaderReflectionType::GetBaseClass() + + + + Gets the number of interfaces. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + Returns the number of interfaces. + int ID3D11ShaderReflectionType::GetNumInterfaces() + + + + Get an interface by index. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + Zero-based index. + A reference to a . + ID3D11ShaderReflectionType* ID3D11ShaderReflectionType::GetInterfaceByIndex([In] int uIndex) + + + + Indicates whether a variable is of the specified type. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A reference to a . + Returns S_OK if object being queried is equal to or inherits from the type in the pType parameter; otherwise returns S_FALSE. + HRESULT ID3D11ShaderReflectionType::IsOfType([In] ID3D11ShaderReflectionType* pType) + + + + Indicates whether a class type implements an interface. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A reference to a . + Returns S_OK if the interface is implemented; otherwise return S_FALSE. + HRESULT ID3D11ShaderReflectionType::ImplementsInterface([In] ID3D11ShaderReflectionType* pBase) + + + + Indicates whether two references have the same underlying type. + + + IsEqual indicates whether the sources of the references have the same underlying type. For example, if two ID3D11ShaderReflectionType Interface references were retrieved from variables, IsEqual can be used to see if the variables have the same type. This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A reference to a . + Returns true if the references have the same underlying type; otherwise returns false. + HRESULT ID3D11ShaderReflectionType::IsEqual([In] ID3D11ShaderReflectionType* pType) + + + + Indicates whether a variable is of the specified type. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A reference to a . + Returns true if object being queried is equal to or inherits from the type in the pType parameter; otherwise returns false. + HRESULT ID3D11ShaderReflectionType::IsOfType([In] ID3D11ShaderReflectionType* pType) + + + + Indicates whether a class type implements an interface. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A reference to a . + Returns true if the interface is implemented; otherwise return false. + HRESULT ID3D11ShaderReflectionType::ImplementsInterface([In] ID3D11ShaderReflectionType* pBase) + + + + Get the description of a shader-reflection-variable type. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + HRESULT ID3D11ShaderReflectionType::GetDesc([Out] D3D11_SHADER_TYPE_DESC* pDesc) + + + + Gets the base class of a class. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + ID3D11ShaderReflectionType* ID3D11ShaderReflectionType::GetSubType() + + + + Gets an interface containing the variable base class type. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + ID3D11ShaderReflectionType* ID3D11ShaderReflectionType::GetBaseClass() + + + + Gets the number of interfaces. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + int ID3D11ShaderReflectionType::GetNumInterfaces() + + + + This shader-reflection interface provides access to a variable. + + ID3D11ShaderReflectionVariable + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a shader-variable description. + + + This method can be used to determine if the is valid, the method returns E_FAIL when the variable is not valid. This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A reference to a shader-variable description (see ). + Returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11ShaderReflectionVariable::GetDesc([Out] D3D11_SHADER_VARIABLE_DESC* pDesc) + + + + Get a shader-variable type. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A reference to a . + ID3D11ShaderReflectionType* ID3D11ShaderReflectionVariable::GetType() + + + + No documentation. + + No documentation. + ID3D11ShaderReflectionConstantBuffer* ID3D11ShaderReflectionVariable::GetBuffer() + + + + Gets the corresponding interface slot for a variable that represents an interface reference. + + + GetInterfaceSlot gets the corresponding slot in an dynamic linkage array for an interface instance. The returned slot number is used to set an interface instance to a particular class instance. See the HLSL {{Interfaces and Classes}} overview for additional information. This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + Index of the array element to get the slot number for. For a non-array variable this value will be zero. + Returns the index of the interface in the interface array. + int ID3D11ShaderReflectionVariable::GetInterfaceSlot([In] int uArrayIndex) + + + + Get a shader-variable description. + + + This method can be used to determine if the is valid, the method returns E_FAIL when the variable is not valid. This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + HRESULT ID3D11ShaderReflectionVariable::GetDesc([Out] D3D11_SHADER_VARIABLE_DESC* pDesc) + + + + No documentation. + + ID3D11ShaderReflectionConstantBuffer* ID3D11ShaderReflectionVariable::GetBuffer() + + + + This shader-reflection interface provides access to a constant buffer. + + ID3D11ShaderReflectionConstantBuffer + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a constant-buffer description. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A reference to a , which represents a shader-buffer description. + Returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11ShaderReflectionConstantBuffer::GetDesc([Out] D3D11_SHADER_BUFFER_DESC* pDesc) + + + + Get a shader-reflection variable by index. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + Zero-based index. + A reference to a shader-reflection variable interface (see ). + ID3D11ShaderReflectionVariable* ID3D11ShaderReflectionConstantBuffer::GetVariableByIndex([In] int Index) + + + + Get a shader-reflection variable by name. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + Variable name. + Returns a sentinel object (end of list marker). To determine if GetVariableByName successfully completed, call and check the returned HRESULT; any return value other than success means that GetVariableByName failed. + ID3D11ShaderReflectionVariable* ID3D11ShaderReflectionConstantBuffer::GetVariableByName([In] const char* Name) + + + + Get a constant-buffer description. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + HRESULT ID3D11ShaderReflectionConstantBuffer::GetDesc([Out] D3D11_SHADER_BUFFER_DESC* pDesc) + + + + A shader-reflection interface accesses shader information. + + ID3D11ShaderReflection + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a shader description. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A reference to a shader description. See . + Returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11ShaderReflection::GetDesc([Out] D3D11_SHADER_DESC* pDesc) + + + + Get a constant buffer by index. + + + A constant buffer supplies either scalar constants or texture constants to a shader. A shader can use one or more constant buffers. For best performance, separate constants into buffers based on the frequency they are updated. This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + Zero-based index. + A reference to a constant buffer (see ). + ID3D11ShaderReflectionConstantBuffer* ID3D11ShaderReflection::GetConstantBufferByIndex([In] int Index) + + + + Get a constant buffer by name. + + + A constant buffer supplies either scalar constants or texture constants to a shader. A shader can use one or more constant buffers. For best performance, separate constants into buffers based on the frequency they are updated. This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + The constant-buffer name. + A reference to a constant buffer (see ). + ID3D11ShaderReflectionConstantBuffer* ID3D11ShaderReflection::GetConstantBufferByName([In] const char* Name) + + + + Get a description of how a resource is bound to a shader. + + + A shader consists of executable code (the compiled HLSL functions) and a set of resources that supply the shader with input data. GetResourceBindingDesc gets information about how one resource in the set is bound as an input to the shader. The ResourceIndex parameter specifies the index for the resource. This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A zero-based resource index. + A reference to an input-binding description. See . + HRESULT ID3D11ShaderReflection::GetResourceBindingDesc([In] int ResourceIndex,[Out] D3D11_SHADER_INPUT_BIND_DESC* pDesc) + + + + Get an input-parameter description for a shader. + + + An input-parameter description is also called a shader signature. The shader signature contains information about the input parameters such as the order or parameters, their data type, and a parameter semantic. This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A zero-based parameter index. + A reference to a shader-input-signature description. See . + HRESULT ID3D11ShaderReflection::GetInputParameterDesc([In] int ParameterIndex,[Out] D3D11_SIGNATURE_PARAMETER_DESC* pDesc) + + + + Get an output-parameter description for a shader. + + + An output-parameter description is also called a shader signature. The shader signature contains information about the output parameters such as the order or parameters, their data type, and a parameter semantic. This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A zero-based parameter index. + A reference to a shader-output-parameter description. See . + HRESULT ID3D11ShaderReflection::GetOutputParameterDesc([In] int ParameterIndex,[Out] D3D11_SIGNATURE_PARAMETER_DESC* pDesc) + + + + Get a patch-constant parameter description for a shader. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A zero-based parameter index. + A reference to a shader-input-signature description. See . + HRESULT ID3D11ShaderReflection::GetPatchConstantParameterDesc([In] int ParameterIndex,[Out] D3D11_SIGNATURE_PARAMETER_DESC* pDesc) + + + + Gets a variable by name. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A reference to a string containing the variable name. + Returns a interface. + ID3D11ShaderReflectionVariable* ID3D11ShaderReflection::GetVariableByName([In] const char* Name) + + + + Get a description of how a resource is bound to a shader. + + + A shader consists of executable code (the compiled HLSL functions) and a set of resources that supply the shader with input data. GetResourceBindingDescByName gets information about how one resource in the set is bound as an input to the shader. The Name parameter specifies the name of the resource. This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + The constant-buffer name of the resource. + A reference to an input-binding description. See . + HRESULT ID3D11ShaderReflection::GetResourceBindingDescByName([In] const char* Name,[Out] D3D11_SHADER_INPUT_BIND_DESC* pDesc) + + + + Gets the number of Mov instructions. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + Returns the number of Mov instructions. + int ID3D11ShaderReflection::GetMovInstructionCount() + + + + Gets the number of Movc instructions. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + Returns the number of Movc instructions. + int ID3D11ShaderReflection::GetMovcInstructionCount() + + + + Gets the number of conversion instructions. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + Returns the number of conversion instructions. + int ID3D11ShaderReflection::GetConversionInstructionCount() + + + + Gets the number of bitwise instructions. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + The number of bitwise instructions. + int ID3D11ShaderReflection::GetBitwiseInstructionCount() + + + + Gets the geometry-shader input-primitive description. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + The input-primitive description, see D3D10_PRIMITIVE_TOPOLOGY. + D3D_PRIMITIVE ID3D11ShaderReflection::GetGSInputPrimitive() + + + + Indicates whether a shader is a sample frequency shader. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + Returns true if the shader is a sample frequency shader; otherwise returns false. + BOOL ID3D11ShaderReflection::IsSampleFrequencyShader() + + + + Gets the number of interface slots in a shader. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + The number of interface slots in the shader. + int ID3D11ShaderReflection::GetNumInterfaceSlots() + + + + Gets the minimum feature level. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + enum D3D_FEATURE_LEVEL A reference to one of the enumerated values in , which represents the minimum feature level. + Returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11ShaderReflection::GetMinFeatureLevel([Out] D3D_FEATURE_LEVEL* pLevel) + + + + Retrieves the sizes, in thread groups, of the X, Y, and Z dimensions of the shader's thread-group grid. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + A reference to the size, in thread groups, of the x-dimension of the thread-group grid. The maximum size is 65535. + A reference to the size, in thread groups, of the y-dimension of the thread-group grid. The maximum size is 65535. + A reference to the size, in thread groups, of the z-dimension of the thread-group grid. The maximum size is 65535. + Returns one of the following {{Direct3D 11 Return Codes}}. + int ID3D11ShaderReflection::GetThreadGroupSize([Out, Optional] int* pSizeX,[Out, Optional] int* pSizeY,[Out, Optional] int* pSizeZ) + + + + Initializes a new instance of the class from a . + + + + + + Get a shader description. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + HRESULT ID3D11ShaderReflection::GetDesc([Out] D3D11_SHADER_DESC* pDesc) + + + + Gets the number of Mov instructions. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + int ID3D11ShaderReflection::GetMovInstructionCount() + + + + Gets the number of Movc instructions. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + int ID3D11ShaderReflection::GetMovcInstructionCount() + + + + Gets the number of conversion instructions. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + int ID3D11ShaderReflection::GetConversionInstructionCount() + + + + Gets the number of bitwise instructions. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + int ID3D11ShaderReflection::GetBitwiseInstructionCount() + + + + Gets the geometry-shader input-primitive description. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + D3D_PRIMITIVE ID3D11ShaderReflection::GetGSInputPrimitive() + + + + Indicates whether a shader is a sample frequency shader. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + BOOL ID3D11ShaderReflection::IsSampleFrequencyShader() + + + + Gets the number of interface slots in a shader. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + int ID3D11ShaderReflection::GetNumInterfaceSlots() + + + + Gets the minimum feature level. + + + This method's interface is hosted in the out-of-box DLL D3DCompiler_xx.dll. + + HRESULT ID3D11ShaderReflection::GetMinFeatureLevel([Out] D3D_FEATURE_LEVEL* pLevel) + + + + No documentation. + + D3D11_REGISTER_COMPONENT_MASK_FLAG + + + + No documentation. + + D3D11_REGISTER_COMPONENT_MASK_ALL + + + + No documentation. + + D3D11_REGISTER_COMPONENT_MASK_COMPONENT_W + + + + No documentation. + + D3D11_REGISTER_COMPONENT_MASK_COMPONENT_X + + + + No documentation. + + D3D11_REGISTER_COMPONENT_MASK_COMPONENT_Y + + + + No documentation. + + D3D11_REGISTER_COMPONENT_MASK_COMPONENT_Z + + + + None. + + None + + + + Describes a shader signature. + + + A shader can take n inputs and can produce m outputs. The order of the input (or output) parameters, their associated types, and any attached semantics make up the shader signature. Each shader has an input and an output signature. When compiling a shader or an effect, some API calls validate shader signatures That is, they compare the output signature of one shader (like a vertex shader) with the input signature of another shader (like a pixel shader). This ensures that a shader outputs data that is compatible with a downstream shader that is consuming that data. Compatible means that a shader signature is a exact-match subset of the preceding shader stage. Exact match means parameter types and semantics must exactly match. Subset means that a parameter that is not required by a downstream stage, does not need to include that parameter in its shader signature. Get a shader-signature from a shader or an effect by calling APIs such as . + + D3D11_SIGNATURE_PARAMETER_DESC + + + + A per-parameter string that identifies how the data will be used. + + const char* SemanticName + + + + Semantic index that modifies the semantic. Used to differentiate different parameters that use the same semantic. + + int SemanticIndex + + + + The register that will contain this variable's data. + + int Register + + + + A predefined string that determines the functionality of certain pipeline stages. See . + + D3D_NAME SystemValueType + + + + The per-component-data type that is stored in a register. See . Each register can store up to four-components of data. + + D3D_REGISTER_COMPONENT_TYPE ComponentType + + + + Mask which indicates which components of a register are used. + + D3D11_REGISTER_COMPONENT_MASK_FLAG Mask + + + + Mask which indicates whether a given component is never written (if the signature is an output signature) or always read (if the signature is an input signature). + + D3D11_REGISTER_COMPONENT_MASK_FLAG ReadWriteMask + + + + Indicates which stream the geometry shader is using for the signature parameter. + + int Stream + + + + Describes a shader constant-buffer. + + + Constants are supplied to shaders in a shader-constant buffer. Get the description of a shader-constant-buffer by calling . + + D3D11_SHADER_BUFFER_DESC + + + + The name of the buffer. + + const char* Name + + + + The intended use of the constant data. + + D3D_CBUFFER_TYPE Type + + + + The number of unique variables. + + int Variables + + + + Buffer size (in bytes). + + int Size + + + + Shader buffer properties. + + D3D_SHADER_CBUFFER_FLAGS uFlags + + + + Describes a shader variable. + + + Get a shader-variable description using reflection, by calling . As of the June 2010 update, DefaultValue emits default values for reflection. + + D3D11_SHADER_VARIABLE_DESC + + + + The variable name. + + const char* Name + + + + Offset from the start of the parent structure, to the beginning of the variable. + + int StartOffset + + + + Size of the variable (in bytes). + + int Size + + + + Flags, which identify shader-variable properties. + + D3D_SHADER_VARIABLE_FLAGS uFlags + + + + The default value for initializing the variable. + + void* DefaultValue + + + + No documentation. + + int StartTexture + + + + No documentation. + + int TextureSize + + + + No documentation. + + int StartSampler + + + + No documentation. + + int SamplerSize + + + + Describes a shader-variable type. + + + Get a shader-variable-type description by calling . + + D3D11_SHADER_TYPE_DESC + + + + Identifies the variable class as one of scalar, vector, matrix or object. See . + + D3D_SHADER_VARIABLE_CLASS Class + + + + The variable type. See . + + D3D_SHADER_VARIABLE_TYPE Type + + + + Number of rows in a matrix. Otherwise a numeric type returns 1, any other type returns 0. + + int Rows + + + + Number of columns in a matrix. Otherwise a numeric type returns 1, any other type returns 0. + + int Columns + + + + Number of elements in an array; otherwise 0. + + int Elements + + + + Number of members in the structure; otherwise 0. + + int Members + + + + Offset, in bytes, between the start of the parent structure and this variable. + + int Offset + + + + No documentation. + + const char* Name + + + + Describes a shader. + + + A shader is written in HLSL and compiled into an intermediate language by the HLSL compiler. The shader description returns information about the compiled shader. Get a shader description by calling . + + D3D11_SHADER_DESC + + + + Shader version. + + int Version + + + + The name of the originator of the shader. + + const char* Creator + + + + Shader compilation/parse flags. + + D3DCOMPILE_SHADER_FLAGS Flags + + + + The number of shader-constant buffers. + + int ConstantBuffers + + + + The number of resource (textures and buffers) bound to a shader. + + int BoundResources + + + + The number of parameters in the input signature. + + int InputParameters + + + + The number of parameters in the output signature. + + int OutputParameters + + + + The number of intermediate-language instructions in the compiled shader. + + int InstructionCount + + + + The number of temporary registers in the compiled shader. + + int TempRegisterCount + + + + Number of temporary arrays used. + + int TempArrayCount + + + + Number of constant defines. + + int DefCount + + + + Number of declarations (input + output). + + int DclCount + + + + Number of non-categorized texture instructions. + + int TextureNormalInstructions + + + + Number of texture load instructions + + int TextureLoadInstructions + + + + Number of texture comparison instructions + + int TextureCompInstructions + + + + Number of texture bias instructions + + int TextureBiasInstructions + + + + Number of texture gradient instructions. + + int TextureGradientInstructions + + + + Number of floating point arithmetic instructions used. + + int FloatInstructionCount + + + + Number of signed integer arithmetic instructions used. + + int IntInstructionCount + + + + Number of unsigned integer arithmetic instructions used. + + int UintInstructionCount + + + + Number of static flow control instructions used. + + int StaticFlowControlCount + + + + Number of dynamic flow control instructions used. + + int DynamicFlowControlCount + + + + Number of macro instructions used. + + int MacroInstructionCount + + + + Number of array instructions used. + + int ArrayInstructionCount + + + + Number of cut instructions used. + + int CutInstructionCount + + + + Number of emit instructions used. + + int EmitInstructionCount + + + + The , which represents the shader output topology. + + D3D_PRIMITIVE_TOPOLOGY GSOutputTopology + + + + Geometry shader maximum output vertex count. + + int GSMaxOutputVertexCount + + + + The -typed value that represents the input primitive for a geometry shader or hull shader. + + D3D_PRIMITIVE InputPrimitive + + + + Number of parameters in the patch-constant signature. + + int PatchConstantParameters + + + + Number of geometry shader instances. + + int cGSInstanceCount + + + + Number of control points in the hull shader and domain shader. + + int cControlPoints + + + + The , which represents the tessellator output-primitive type. + + D3D_TESSELLATOR_OUTPUT_PRIMITIVE HSOutputPrimitive + + + + The , which represents the tessellator partitioning mode. + + D3D_TESSELLATOR_PARTITIONING HSPartitioning + + + + The , which represents the tessellator domain. + + D3D_TESSELLATOR_DOMAIN TessellatorDomain + + + + Number of barrier instructions in a compute shader. + + int cBarrierInstructions + + + + Number of interlocked instructions in a compute shader. + + int cInterlockedInstructions + + + + Number of texture writes in a compute shader. + + int cTextureStoreInstructions + + + + Describes how a shader resource is bound to a shader input. + + + Get a shader-input-signature description by calling or . + + D3D11_SHADER_INPUT_BIND_DESC + + + + Name of the shader resource. + + const char* Name + + + + Identifies the type of data in the resource. See . + + D3D_SHADER_INPUT_TYPE Type + + + + Starting bind point. + + int BindPoint + + + + Number of contiguous bind points for arrays. + + int BindCount + + + + Shader input-parameter options. See . + + D3D_SHADER_INPUT_FLAGS uFlags + + + + If the input is a texture, the return type. See . + + D3D_RESOURCE_RETURN_TYPE ReturnType + + + + Identifies the dimensions of the bound resource. For a list of values that or can return, see . + + D3D_SRV_DIMENSION Dimension + + + + The number of samples for a multisampled texture; otherwise 0. + + int NumSamples + + + + Describes shader data. + + + An array of D3D_SHADER_DATA structures is passed to to compress the shader data into a more compact form. + + D3D_SHADER_DATA + + + + A reference to shader data. + + const void* pBytecode + + + + Length of shader data that pBytecode points to. + + SIZE_T BytecodeLength + + + + Internal Include Callback + + + + + A user-implemented method for opening and reading the contents of a shader #include file. + + This pointer + A -typed value that indicates the location of the #include file. + Name of the #include file. + Pointer to the container that includes the #include file. + Pointer to the buffer that Open returns that contains the include directives. This pointer remains valid until is called. + Pointer to the number of bytes that Open returns in ppData. + The user-implemented method should return S_OK. If Open fails when reading the #include file, the application programming interface (API) that caused Open to be called fails. This failure can occur in one of the following situations:The high-level shader language (HLSL) shader fails one of the D3D10CompileShader*** functions.The effect fails one of the D3D10CreateEffect*** functions. + HRESULT Open([None] D3D_INCLUDE_TYPE IncludeType,[None] const char* pFileName,[None] LPCVOID pParentData,[None] LPCVOID* ppData,[None] UINT* pBytes) + + + + A user-implemented method for closing a shader #include file. + + + If was successful, Close is guaranteed to be called before the API using the interface returns. + + This pointer + Pointer to the buffer that contains the include directives. This is the pointer that was returned by the corresponding call. + The user-implemented Close method should return S_OK. If Close fails when it closes the #include file, the application programming interface (API) that caused Close to be called fails. This failure can occur in one of the following situations:The high-level shader language (HLSL) shader fails one of the D3D10CompileShader*** functions.The effect fails one of the D3D10CreateEffect*** functions. + HRESULT Close([None] LPCVOID pData) + + + + Represents the compiled bytecode of a shader or effect. + + Blob + + + + Initializes a new instance of the class. + + A containing the compiled bytecode. + + + + Initializes a new instance of the class. + + A containing the compiled bytecode. + + + + Initializes a new instance of the class. + + The buffer. + + + + Initializes a new instance of the class. + + a pointer to a compiler bytecode + size of the bytecode + + + + Initializes a new instance of the class. + + The BLOB. + + + + Compiles the provided shader or effect source. + + A string containing the source of the shader or effect to compile. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + The compiled shader bytecode, or null if the method fails. + + + + Compiles the provided shader or effect source. + + An array of bytes containing the raw source of the shader or effect to compile. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + The compiled shader bytecode, or null if the method fails. + + + + Compiles the provided shader or effect source. + + A string containing the source of the shader or effect to compile. + The name of the shader entry-point function, or null for an effect file. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + The compiled shader bytecode, or null if the method fails. + + + + Compiles the provided shader or effect source. + + An array of bytes containing the raw source of the shader or effect to compile. + The name of the shader entry-point function, or null for an effect file. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + The compiled shader bytecode, or null if the method fails. + + + + Compiles the provided shader or effect source. + + A string containing the source of the shader or effect to compile. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + A set of macros to define during compilation. + An interface for handling include files. + The compiled shader bytecode, or null if the method fails. + + + + Compiles the provided shader or effect source. + + An array of bytes containing the raw source of the shader or effect to compile. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + A set of macros to define during compilation. + An interface for handling include files. + The compiled shader bytecode, or null if the method fails. + + + + Compiles the provided shader or effect source. + + A string containing the source of the shader or effect to compile. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + A set of macros to define during compilation. + An interface for handling include files. + When the method completes, contains a string of compilation errors, or an empty string if compilation succeeded. + The compiled shader bytecode, or null if the method fails. + + + + Compiles the provided shader or effect source. + + An array of bytes containing the raw source of the shader or effect to compile. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + A set of macros to define during compilation. + An interface for handling include files. + When the method completes, contains a string of compilation errors, or an empty string if compilation succeeded. + The compiled shader bytecode, or null if the method fails. + + + + Compiles the provided shader or effect source. + + A string containing the source of the shader or effect to compile. + The name of the shader entry-point function, or null for an effect file. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + A set of macros to define during compilation. + An interface for handling include files. + The compiled shader bytecode, or null if the method fails. + + + + Compiles the provided shader or effect source. + + An array of bytes containing the raw source of the shader or effect to compile. + The name of the shader entry-point function, or null for an effect file. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + A set of macros to define during compilation. + An interface for handling include files. + The compiled shader bytecode, or null if the method fails. + + + + Compiles the provided shader or effect source. + + An array of bytes containing the raw source of the shader or effect to compile. + The name of the shader entry-point function, or null for an effect file. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + A set of macros to define during compilation. + An interface for handling include files. + When the method completes, contains a string of compilation errors, or an empty string if compilation succeeded. + The compiled shader bytecode, or null if the method fails. + + + + Compiles the provided shader or effect source. + + A string containing the source of the shader or effect to compile. + The name of the shader entry-point function, or null for an effect file. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + A set of macros to define during compilation. + An interface for handling include files. + When the method completes, contains a string of compilation errors, or an empty string if compilation succeeded. + The compiled shader bytecode, or null if the method fails. + + + + Compiles a shader or effect from a file on disk. + + The name of the source file to compile. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + The compiled shader bytecode, or null if the method fails. + + + + Compiles a shader or effect from a file on disk. + + The name of the source file to compile. + The name of the shader entry-point function, or null for an effect file. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + The compiled shader bytecode, or null if the method fails. + + + + Compiles a shader or effect from a file on disk. + + The name of the source file to compile. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + A set of macros to define during compilation. + An interface for handling include files. + The compiled shader bytecode, or null if the method fails. + + + + Compiles a shader or effect from a file on disk. + + The name of the source file to compile. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + A set of macros to define during compilation. + An interface for handling include files. + When the method completes, contains a string of compilation errors, or an empty string if compilation succeeded. + The compiled shader bytecode, or null if the method fails. + + + + Compiles a shader or effect from a file on disk. + + The name of the source file to compile. + The name of the shader entry-point function, or null for an effect file. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + A set of macros to define during compilation. + An interface for handling include files. + The compiled shader bytecode, or null if the method fails. + + + + Compiles a shader or effect from a file on disk. + + The name of the source file to compile. + The name of the shader entry-point function, or null for an effect file. + The shader target or set of shader features to compile against. + Shader compilation options. + Effect compilation options. + A set of macros to define during compilation. + An interface for handling include files. + When the method completes, contains a string of compilation errors, or an empty string if compilation succeeded. + The compiled shader bytecode, or null if the method fails. + + + + Compresses a set of shaders into a more compact form. + + An array of structures that describe the set of shaders to compress. + A compressed . + HRESULT D3DCompressShaders([In] int uNumShaders,[In, Buffer] D3D_SHADER_DATA* pShaderData,[In] int uFlags,[Out] ID3DBlob** ppCompressedData) + + + + Disassembles compiled HLSL code back into textual source. + + The textual source of the shader or effect. + + + + Disassembles compiled HLSL code back into textual source. + + Flags affecting the output of the disassembly. + The textual source of the shader or effect. + + + + Disassembles compiled HLSL code back into textual source. + + Flags affecting the output of the disassembly. + Commenting information to embed in the disassembly. + The textual source of the shader or effect. + + + + Retrieves a specific part from a compilation result. + + + D3DGetBlobPart retrieves the part of a blob (arbitrary length data buffer) that contains the type of data that the Part parameter specifies. + + A -typed value that specifies the part of the buffer to retrieve. + Returns the extracted part. + HRESULT D3DGetBlobPart([In, Buffer] const void* pSrcData,[In] SIZE_T SrcDataSize,[In] D3D_BLOB_PART Part,[In] int Flags,[Out] ID3DBlob** ppPart) + + + + Froms the pointer. + + The pointer. + + + + + Preprocesses the provided shader or effect source. + + A string containing the source of the shader or effect to preprocess. + The preprocessed shader source. + + + + Preprocesses the provided shader or effect source. + + An array of bytes containing the raw source of the shader or effect to preprocess. + The preprocessed shader source. + + + + Preprocesses the provided shader or effect source. + + A string containing the source of the shader or effect to preprocess. + A set of macros to define during preprocessing. + An interface for handling include files. + The preprocessed shader source. + + + + Preprocesses the provided shader or effect source. + + An array of bytes containing the raw source of the shader or effect to preprocess. + A set of macros to define during preprocessing. + An interface for handling include files. + The preprocessed shader source. + + + + Preprocesses the provided shader or effect source. + + An array of bytes containing the raw source of the shader or effect to preprocess. + A set of macros to define during preprocessing. + An interface for handling include files. + When the method completes, contains a string of compilation errors, or an empty string if preprocessing succeeded. + The preprocessed shader source. + + + + Preprocesses the provided shader or effect source. + + A string containing the source of the shader or effect to preprocess. + A set of macros to define during preprocessing. + An interface for handling include files. + When the method completes, contains a string of compilation errors, or an empty string if preprocessing succeeded. + The preprocessed shader source. + + + + Preprocesses a shader or effect from a file on disk. + + The name of the source file to compile. + The preprocessed shader source. + + + + Preprocesses a shader or effect from a file on disk. + + The name of the source file to compile. + A set of macros to define during preprocessing. + An interface for handling include files. + The preprocessed shader source. + + + + Preprocesses a shader or effect from a file on disk. + + The name of the source file to compile. + A set of macros to define during preprocessing. + An interface for handling include files. + When the method completes, contains a string of compilation errors, or an empty string if preprocessing succeeded. + The preprocessed shader source. + + + + Strips extraneous information from a compiled shader or effect. + + Options specifying what to remove from the shader. + A string containing any errors that may have occurred. + + + + Read a compiled shader bytecode from a Stream and return a ShaderBytecode + + + + + + + Read a compiled shader bytecode from a Stream and return a ShaderBytecode + + + + + + + Gets this instance is composed of compressed shaders. + + + true if this instance is compressed; otherwise, false. + + + + + Gets the raw data of the compiled bytecode. + + + + + Represents a shader signature. + + + + + Initializes a new instance of the class. + + A pointer to a Blob object. + + + + Extracts the input and output signatures from a compiled shader or effect. + + The bytecode of the compiled shader or effect. + The input and output signatures of the shader or effect. + + + + Extracts the input signature from a compiled shader or effect. + + The bytecode of the compiled shader or effect. + The input signature of the shader or effect. + + + + Extracts the output signature from a compiled shader or effect. + + The bytecode of the compiled shader or effect. + The output signature of the shader or effect. + + + + Gets the raw data of the shader signature. + + + + diff --git a/Libs/SharpDX.DXGI.dll b/Libs/SharpDX.DXGI.dll new file mode 100644 index 0000000000000000000000000000000000000000..138c7fed1b06a03d660946486a6b9d049a902769 GIT binary patch literal 53248 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 bsQXRlp$fA + + + SharpDX.DXGI + + + + + The IDXGIAdapter interface represents a display sub-system (including one or more GPU's, DACs and video memory). + + IDXGIAdapter + + + + An IDXGIObject interface is a base interface for all DXGI objects; IDXGIObject supports associating caller-defined (private data) with an object and retrieval of an interface to the parent object. + + IDXGIObject + + + + + + + + + + Initializes a new instance of the class. + + The native pointer. + + + + Sets an IUnknown interface as private data; this associates application-defined data with the object. + + + This API makes a copy of the specified data and stores it with the object. + + A GUID identifying the data. This GUID will also be used when getting the data. + The size of the object's data. + Pointer to the object's data. + Returns one of the following . + HRESULT IDXGIObject::SetPrivateData([In] GUID* Name,[None] int DataSize,[In, Buffer] const void* pData) + + + + Set an interface in the object's private data. + + + This API associates an interface reference with the object. When the interface is set its reference count is incremented. When the data are overwritten (by calling SPD or SPDI with the same GUID) or the object is destroyed, ::Release() is called and the interface's reference count is decremented. + + A GUID identifying the interface. + The interface to set. + Returns one of the following . + HRESULT IDXGIObject::SetPrivateDataInterface([In] GUID* Name,[In] const IUnknown* pUnknown) + + + + Get a reference to the object's data. + + + If the data returned is a reference to an IUnknown, or one of its derivative classes, previously set by , then ::Release() must be called on the reference before the reference is freed to decrement the reference count. + + A GUID identifying the data. + The size of the data. + Pointer to the data. + Returns one of the following . + HRESULT IDXGIObject::GetPrivateData([In] GUID* Name,[InOut] int* pDataSize,[Out, Buffer] void* pData) + + + + Gets the parent of the object. + + + The following diagram shows the possible parent types for DXGI objects. ? Diagram of possible parents for DXGI objects ? The identifier of the interface an object supports can be obtained like so: + __uuidof(*ppParent) + + + + The ID of the requested interface. See remarks. + The address of a reference to the parent object. + Returns one of the following . + HRESULT IDXGIObject::GetParent([In] GUID* riid,[Out] void** ppParent) + + + + Checks to see if a device interface for a graphics component is supported by the system. + + The GUID of the interface of the device version for which support is being checked. For example, typeof(ID3D10Device).GUID. + + true if the interface is supported; otherwise, false. + + HRESULT IDXGIAdapter::CheckInterfaceSupport([In] GUID* InterfaceName,[Out] __int64* pUMDVersion) + + + + Checks to see if a device interface for a graphics component is supported by the system. + + the interface of the device version for which support is being checked. + + true if the interface is supported; otherwise, false. + + + + + Checks to see if a device interface for a graphics component is supported by the system. + + the interface of the device version for which support is being checked. + The user mode driver version of InterfaceName. This is only returned if the interface is supported. + + true if the interface is supported; otherwise, false. + + + + + Checks to see if a device interface for a graphics component is supported by the system. + + The GUID of the interface of the device version for which support is being checked. For example, typeof(ID3D10Device).GUID. + The user mode driver version of InterfaceName. This is only returned if the interface is supported. + + true if the interface is supported; otherwise, false. + + HRESULT IDXGIAdapter::CheckInterfaceSupport([In] GUID* InterfaceName,[Out] __int64* pUMDVersion) + + + + Return the number of available outputs from this adapter. + + The number of outputs + + + + Initializes a new instance of the class. + + The native pointer. + + + + Enumerate adapter (video card) outputs. + + + If the method succeeds, the reference count on the output interface will be incremented. To avoid a memory leak, be sure to release the interface when you are finished with it. Here is an example of how to use this function to enumerate all the outputs on an adapter: + UINT i = 0; + IDXGIOutput * pOutput; + std::vector<IDXGIOutput*> vOutputs; + while(pAdapter->EnumOutputs(i, &pOutput) != DXGI_ERROR_NOT_FOUND) + { vOutputs.push_back(pOutput); ++i; + } + + + + The index of the output. + The address of a reference to an output (see ). + HRESULT IDXGIAdapter::EnumOutputs([None] int Output,[Out] IDXGIOutput** ppOutput) + + + + Gets a DXGI 1.0 description of an adapter (or video card). + + + Graphics applications can use the DXGI API to retrieve an accurate set of graphics memory values on systems that have WDDM drivers. The following are the critical steps involved. Graphics driver model determination ? Because DXGI is only available on systems with WDDM drivers, the application must first confirm the driver model by using the following API. + HasWDDMDriver() + { LPDIRECT3DCREATE9EX pD3D9Create9Ex = NULL; HMODULE hD3D9 = NULL; hD3D9 = LoadLibrary( L"d3d9.dll" ); if ( NULL == hD3D9 ) { return false; } // /* Try to create IDirect3D9Ex interface (also known as a DX9L interface). This interface can only be created if the driver is a WDDM driver. */ // pD3D9Create9Ex = (LPDIRECT3DCREATE9EX) GetProcAddress( hD3D9, "Direct3DCreate9Ex" ); return pD3D9Create9Ex != NULL; + } + + Retrieval of graphics memory values.? After the driver model is determined to be WDDM, the application can use the DirectX 10 or later API and DXGI to get the amount of graphics memory. After creating a Direct3D device the following code can be used to obtain a structure containing the amount of available graphics memory. + IDXGIDevice * pDXGIDevice; + hr = g_pd3dDevice->QueryInterface(__uuidof(IDXGIDevice), (void **)&pDXGIDevice); + IDXGIAdapter * pDXGIAdapter; + pDXGIDevice->GetAdapter(&pDXGIAdapter); + DXGI_ADAPTER_DESC adapterDesc; + pDXGIAdapter->GetDesc(&adapterDesc); + + + + A reference to a structure that describes the adapter. This parameter must not be NULL. + Returns S_OK if successful; otherwise returns an error code. Returns if the pDesc parameter is NULL. For a list of error codes, see DXGI_ERROR. + HRESULT IDXGIAdapter::GetDesc([Out] DXGI_ADAPTER_DESC* pDesc) + + + + Checks to see if a device interface for a graphics component is supported by the system. + + The GUID of the interface of the device version for which support is being checked. For example, __uuidof(ID3D10Device). + The user mode driver version of InterfaceName. This is only returned if the interface is supported. This parameter can be NULL. + S_OK indicates that the interface is supported, otherwise DXGI_ERROR_UNSUPPORTED is returned (See ). + HRESULT IDXGIAdapter::CheckInterfaceSupport([In] GUID* InterfaceName,[Out] __int64* pUMDVersion) + + + + Gets a DXGI 1.0 description of an adapter (or video card). + + + Graphics applications can use the DXGI API to retrieve an accurate set of graphics memory values on systems that have WDDM drivers. The following are the critical steps involved. Graphics driver model determination ? Because DXGI is only available on systems with WDDM drivers, the application must first confirm the driver model by using the following API. + HasWDDMDriver() + { LPDIRECT3DCREATE9EX pD3D9Create9Ex = NULL; HMODULE hD3D9 = NULL; hD3D9 = LoadLibrary( L"d3d9.dll" ); if ( NULL == hD3D9 ) { return false; } // /* Try to create IDirect3D9Ex interface (also known as a DX9L interface). This interface can only be created if the driver is a WDDM driver. */ // pD3D9Create9Ex = (LPDIRECT3DCREATE9EX) GetProcAddress( hD3D9, "Direct3DCreate9Ex" ); return pD3D9Create9Ex != NULL; + } + + Retrieval of graphics memory values.? After the driver model is determined to be WDDM, the application can use the DirectX 10 or later API and DXGI to get the amount of graphics memory. After creating a Direct3D device the following code can be used to obtain a structure containing the amount of available graphics memory. + IDXGIDevice * pDXGIDevice; + hr = g_pd3dDevice->QueryInterface(__uuidof(IDXGIDevice), (void **)&pDXGIDevice); + IDXGIAdapter * pDXGIAdapter; + pDXGIDevice->GetAdapter(&pDXGIAdapter); + DXGI_ADAPTER_DESC adapterDesc; + pDXGIAdapter->GetDesc(&adapterDesc); + + + + HRESULT IDXGIAdapter::GetDesc([Out] DXGI_ADAPTER_DESC* pDesc) + + + + An IDXGIDevice interface implements a derived class for DXGI objects that produce image data. + + IDXGIDevice + + + + Gets the residency status of an array of resources. + + + The information returned by the pResidencyStatus argument array describes the residency status at the time that the QueryResourceResidency method was called. Note that the residency status will constantly change. If you call the QueryResourceResidency method during a device removed state, the pResidencyStatus argument will return the DXGI_RESIDENCY_EVICTED_TO_DISK flag. Note??This method should not be called every frame as it incurs a non-trivial amount of overhead. + + An array of interfaces. + Returns an array of flags. Each element describes the residency status for corresponding element in the ppResources argument array. + HRESULT IDXGIDevice::QueryResourceResidency([In, Buffer] const IUnknown** ppResources,[Out, Buffer] DXGI_RESIDENCY* pResidencyStatus,[None] int NumResources) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Returns the adapter for the specified device. + + + If the GetAdapter method succeeds, the reference count on the adapter interface will be incremented. To avoid a memory leak, be sure to release the interface when you are finished using it. + + The address of an interface reference to the adapter. This parameter must not be NULL. + Returns S_OK if successful; otherwise, returns one of the that indicates failure. If the pAdapter parameter is NULL this method returns . + HRESULT IDXGIDevice::GetAdapter([Out] IDXGIAdapter** pAdapter) + + + + Returns a surface. This method is used internally and you should not call it directly in your application. + + + The CreateSurface method creates a buffer to exchange data between one or more devices. It is used internally, and you should not directly call it. The runtime automatically creates an interface when it creates a Direct3D resource object that represents a surface. For example, the runtime creates an IDXGISurface interface when it calls or to create a 2D texture. To retrieve the IDXGISurface interface that represents the 2D texture surface, call {{ID3D11Texture2D::QueryInterface}} or ID3D10Texture2D::QueryInterface. In this call, you must pass the identifier of IDXGISurface. If the 2D texture has only a single MIP-map level and does not consist of an array of textures, QueryInterface succeeds and returns a reference to the IDXGISurface interface reference. Otherwise, QueryInterface fails and does not return the reference to IDXGISurface. + + + A reference to a structure that describes the surface. + The number of surfaces to create. + A flag that specifies how the surface is expected to be used. + An optional reference to a structure that contains shared resource information for opening views of such resources. + The address of an interface reference to the first created surface. + Returns S_OK if successful; an error code otherwise. For a list of error codes, see . + HRESULT IDXGIDevice::CreateSurface([In] const DXGI_SURFACE_DESC* pDesc,[None] int NumSurfaces,[None] DXGI_USAGE Usage,[In, Optional] const DXGI_SHARED_RESOURCE* pSharedResource,[Out] IDXGISurface** ppSurface) + + + + Gets the residency status of an array of resources. + + + The information returned by the pResidencyStatus argument array describes the residency status at the time that the QueryResourceResidency method was called. Note that the residency status will constantly change. If you call the QueryResourceResidency method during a device removed state, the pResidencyStatus argument will return the DXGI_RESIDENCY_EVICTED_TO_DISK flag. Note??This method should not be called every frame as it incurs a non-trivial amount of overhead. + + An array of interfaces. + An array of flags. Each element describes the residency status for corresponding element in the ppResources argument array. + The number of resources in the ppResources argument array and pResidencyStatus argument array. + Returns S_OK if successfull; otherwise, returns , E_INVALIDARG, or E_POINTER (see {{WinError.h}} for more information). + HRESULT IDXGIDevice::QueryResourceResidency([In, Buffer] const IUnknown** ppResources,[Out, Buffer] DXGI_RESIDENCY* pResidencyStatus,[None] int NumResources) + + + + Sets the GPU thread priority. + + + The values for the Priority parameter function as follows: Positive values increase the likelihood that the GPU scheduler will grant GPU execution cycles to the device when rendering. Negative values lessen the likelihood that the device will receive GPU execution cycles when devices compete for them. The device is guaranteed to receive some GPU execution cycles at all settings. To use the SetGPUThreadPriority method, you should have a comprehensive understanding of GPU scheduling. You should profile your application to ensure that it behaves as intended. If used inappropriately, the SetGPUThreadPriority method can impede rendering speed and result in a poor user experience. + + A value that specifies the required GPU thread priority. This value must be between -7 and 7, inclusive, where 0 represents normal priority. + Return S_OK if successful; otherwise, returns E_INVALIDARG if the Priority parameter is invalid. + HRESULT IDXGIDevice::SetGPUThreadPriority([None] int Priority) + + + + Gets the GPU thread priority. + + A reference to a variable that receives a value that indicates the current GPU thread priority. The value will be between -7 and 7, inclusive, where 0 represents normal priority. + Return S_OK if successful; otherwise, returns E_POINTER if the pPriority parameter is NULL. + HRESULT IDXGIDevice::GetGPUThreadPriority([Out] int* pPriority) + + + + Returns the adapter for the specified device. + + + If the GetAdapter method succeeds, the reference count on the adapter interface will be incremented. To avoid a memory leak, be sure to release the interface when you are finished using it. + + HRESULT IDXGIDevice::GetAdapter([Out] IDXGIAdapter** pAdapter) + + + + Gets the GPU thread priority. + + HRESULT IDXGIDevice::GetGPUThreadPriority([Out] int* pPriority) + + + + Inherited from objects that are tied to the device so that they can retrieve a reference to it. + + IDXGIDeviceSubObject + + + + Retrieves the device. + + The interface that is returned can be any interface published by the device. + The associated device. + HRESULT IDXGIDeviceSubObject::GetDevice([In] GUID* riid,[Out] void** ppDevice) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Retrieves the device. + + + The type of interface that is returned can be any interface published by the device. For example, it could be an IDXGIDevice * called pDevice, and therefore the REFIID would be obtained by calling __uuidof(pDevice). + + The reference id for the device. + The address of a reference to the device. + A code that indicates success or failure (see ). + HRESULT IDXGIDeviceSubObject::GetDevice([In] GUID* riid,[Out] void** ppDevice) + + + + An IDXGIFactory interface implements methods for generating DXGI objects (which handle fullscreen transitions). + + IDXGIFactory + + + + Default Constructor for Factory + + + + + Create an adapter interface that represents a software adapter. + + + A software adapter is a DLL that implements the entirety of a device driver interface, plus emulation, if necessary, of kernel-mode graphics components for Windows. Details on implementing a software adapter can be found in the Windows Vista Driver Development Kit. This is a very complex development task, and is not recommended for general readers. Calling this method will increment the module's reference count by one. The reference count can be decremented by calling {{FreeLibrary}}. The typical calling scenario is to call {{LoadLibrary}}, pass the handle to CreateSoftwareAdapter, then immediately call {{FreeLibrary}} on the DLL and forget the DLL's {{HMODULE}}. Since the software adapter calls FreeLibrary when it is destroyed, the lifetime of the DLL will now be owned by the adapter, and the application is free of any further consideration of its lifetime. + + Handle to the software adapter's dll. + A reference to an adapter (see ). + HRESULT IDXGIFactory::CreateSoftwareAdapter([None] void* Module,[Out] IDXGIAdapter** ppAdapter) + + + + Return the number of available adapters from this factory. + + The number of adapters + + + + Initializes a new instance of the class. + + The native pointer. + + + + Enumerates the adapters (video cards). + + + The set of adapters available in the system is enumerated when the factory is created. Therefore, if you change the adapters in a system, you must destroy and recreate the object. The number of adapters adapters in a system changes when you add or remove a display card, or dock or undock a laptop. When the EnumAdapters method succeeds and the adapter interface is filled, the adapters reference count will be incremented. When you are finished with the adapter interface, be sure to call the Release method to decrement the reference count before you destroy the reference. + + The index of the adapter to enumerate. + The address of a reference to as interface at the position specified by the Adapter parameter. This parameter must not be NULL. + HRESULT IDXGIFactory::EnumAdapters([None] int Adapter,[Out] IDXGIAdapter** ppAdapter) + + + + Allows DXGI to monitor an application's message queue for the alt-enter key sequence (which causes the application to switch from windowed to fullscreen or vice versa). + + + The combination of WindowHandle and Flags informs DXGI to stop monitoring window messages for the previously-associated window. If the application switches to full-screen mode, DXGI will choose a full-screen resolution to be the smallest supported resolution that is larger or the same size as the current back buffer size. Applications can make some changes to make the transition from windowed to full screen more efficient. For example, on a WM_SIZE message, the application should release any outstanding swap-chain back buffers, call , then re-acquire the back buffers from the swap chain(s). This gives the swap chain(s) an opportunity to resize the back buffers, and/or recreate them to enable full-screen flipping operation. If the application does not perform this sequence, DXGI will still make the full-screen/windowed transition, but may be forced to use a stretch operation (since the back buffers may not be the correct size), which may be less efficient. Even if a stretch is not required, presentation may not be optimal because the back buffers might not be directly interchangeable with the front buffer. Thus, a call to ResizeBuffers on WM_SIZE is always recommended, since WM_SIZE is always sent during a fullscreen transition. While windowed, the application can, if it chooses, restrict the size of its window's client area to sizes to which it is comfortable rendering. A fully flexible application would make no such restriction, but UI elements or other design considerations can, of course, make this flexibility untenable. If the application further chooses to restrict its window's client area to just those that match supported full-screen resolutions, the application can field WM_SIZING, then check against . If a matching mode is found, allow the resize. (The IDXGIOutput can be retrieved from . Absent subsequent changes to desktop topology, this will be the same output that will be chosen when alt-enter is fielded and fullscreen mode is begun for that swap chain.) Applications that want to handle mode changes or Alt+Enter themselves should call MakeWindowAssociation with the DXGI_MWA_NO_WINDOW_CHANGES flag after swap chain creation. The WindowHandle argument, if non-NULL, specifies that the application message queues will not be handled by the DXGI runtime for all swap chains of a particular target {{HWND}}. Calling MakeWindowAssociation with the DXGI_MWA_NO_WINDOW_CHANGES flag after swapchain creation ensures that DXGI will not interfere with application's handling of window mode changes or Alt+Enter. + + The handle of the window that is to be monitored. This parameter can be NULL; but only if the flags are also 0. + One or more of the following values: DXGI_MWA_NO_WINDOW_CHANGES - Prevent DXGI from monitoring an applications message queue; this makes DXGI unable to respond to mode changes. DXGI_MWA_NO_ALT_ENTER - Prevent DXGI from responding to an alt-enter sequence. DXGI_MWA_NO_PRINT_SCREEN - Prevent DXGI from responding to a print-screen key. + if WindowHandle is invalid, or E_OUTOFMEMORY. + HRESULT IDXGIFactory::MakeWindowAssociation([None] void* WindowHandle,[None] DXGI_MWA_FLAGS Flags) + + + + Get the window through which the user controls the transition to and from fullscreen. + + A reference to a window handle. + HRESULT IDXGIFactory::GetWindowAssociation([Out] void** pWindowHandle) + + + + Creates a swap chain. + + + If you attempt to create a swap chain in full-screen mode, and full-screen mode is unavailable, the swap chain will be created in windowed mode and DXGI_STATUS_OCCLUDED will be returned. If the buffer width or the buffer height are zero, the sizes will be inferred from the output window size in the swap-chain description. Since the target output cannot be chosen explicitly when the swap-chain is created, you should not create a full-screen swap chain. This can reduce presentation performance if the swap chain size and the output window size do not match. Here are two ways to ensure the sizes match: Create a windowed swap chain and then set it full-screen using . Save a reference to the swap-chain immediately after creation, and use it to get the output window size during a WM_SIZE event. Then resize the swap chain buffers (with ) during the transition from windowed to full-screen. If the swap chain is in full-screen mode, before you release it, you must use {{SetFullscreenState}} to switch it to windowed mode. For more information about releasing a swap chain, see the Destroying a Swap Chain section of {{DXGI Overview}}. + + A reference to the device that will write 2D images to the swap chain. + A reference to the swap-chain description (see ). This parameter cannot be NULL. + A reference to the swap chain created (see ). + if pDesc or ppSwapChain is NULL, DXGI_STATUS_OCCLUDED if you request full-screen mode and it is unavailable, or E_OUTOFMEMORY. Other error codes defined by the type of device passed in may also be returned. + HRESULT IDXGIFactory::CreateSwapChain([In] IUnknown* pDevice,[In] DXGI_SWAP_CHAIN_DESC* pDesc,[Out] IDXGISwapChain** ppSwapChain) + + + + Create an adapter interface that represents a software adapter. + + + A software adapter is a DLL that implements the entirety of a device driver interface, plus emulation, if necessary, of kernel-mode graphics components for Windows. Details on implementing a software adapter can be found in the Windows Vista Driver Development Kit. This is a very complex development task, and is not recommended for general readers. Calling this method will increment the module's reference count by one. The reference count can be decremented by calling {{FreeLibrary}}. The typical calling scenario is to call {{LoadLibrary}}, pass the handle to CreateSoftwareAdapter, then immediately call {{FreeLibrary}} on the DLL and forget the DLL's {{HMODULE}}. Since the software adapter calls FreeLibrary when it is destroyed, the lifetime of the DLL will now be owned by the adapter, and the application is free of any further consideration of its lifetime. + + Handle to the software adapter's dll. HMODULE can be obtained with {{GetModuleHandle}} or {{LoadLibrary}}. + Address of a reference to an adapter (see ). + HRESULT IDXGIFactory::CreateSoftwareAdapter([None] void* Module,[Out] IDXGIAdapter** ppAdapter) + + + + The IDXGIFactory1 interface implements methods for generating DXGI objects. + + IDXGIFactory1 + + + + Default Constructor for Factory1. + + + + + Return the number of available adapters from this factory. + + The number of adapters + + + + Initializes a new instance of the class. + + The native pointer. + + + + Enumerates both adapters (video cards) with or without outputs. + + + The set of adapters available in the system is enumerated when the factory is created. Therefore, if you change the adapters in a system, you must destroy and recreate the object. The number of adapters adapters in a system changes when you add or remove a display card, or dock or undock a laptop. When the EnumAdapters1 method succeeds and the adapter interface is filled, the adapters reference count will be incremented. When you are finished with the adapter interface, be sure to call the Release method to decrement the reference count before you destroy the reference. The local adapter with output on which the Desktop primary is displayed is returned first, followed by other adapter(s) with outputs, then adapter(s) without outputs. + + The index of the adapter to enumerate. + The address of a reference to as interface at the position specified by the Adapter parameter. This parameter must not be NULL. + HRESULT IDXGIFactory1::EnumAdapters1([None] int Adapter,[Out] IDXGIAdapter1** ppAdapter) + + + + Informs an application of the possible need to re-enumerate adapters. + + FALSE, if a new adapter is becoming available or the current adapter is going away. TRUE, no adapter changes. IsCurrent returns FALSE to inform the calling application to re-enumerate adapters. + BOOL IDXGIFactory1::IsCurrent() + + + + Informs an application of the possible need to re-enumerate adapters. + + BOOL IDXGIFactory1::IsCurrent() + + + + Helper to use with . + + + + + Calculates the size of a in bytes. + + The dxgi format. + size of in bytes + + + + Calculates the size of a in bits. + + The dxgi format. + size of in bits + + + + Flags indicating the memory location of a resource. + + DXGI_RESIDENCY + + + + The resource is located in video memory. + + DXGI_RESIDENCY_FULLY_RESIDENT + + + + At least some of the resource is located in CPU memory. + + DXGI_RESIDENCY_RESIDENT_IN_SHARED_MEMORY + + + + At least some of the resource has been paged out to the hard drive. + + DXGI_RESIDENCY_EVICTED_TO_DISK + + + + Options for handling pixels in a display surface after calling . + + + This enumeration is used by the structure. + + DXGI_SWAP_EFFECT + + + + Use this flag to indicate that the contents of the back buffer are discarded after calling IDXGISwapChain::Present. This flag is valid for a swap chain with more than one back buffer, although, an application only has read and write access to buffer 0. Use this flag to enable the display driver to select the most efficient presentation technique for the swap chain. + + DXGI_SWAP_EFFECT_DISCARD + + + + Use this flag to indicate that the contents of the back buffer are not discarded after calling IDXGISwapChain::Present. Use this option to present the contents of the swap chain in order, from the first buffer (buffer 0) to the last buffer. This flag cannot be used with multisampling. + + DXGI_SWAP_EFFECT_SEQUENTIAL + + + + Options for swap-chain behavior. + + + This enumeration is used by the structure. + + DXGI_SWAP_CHAIN_FLAG + + + + Turn off automatic image rotation; that is, do not perform a rotation when transfering the contents of the front buffer to the monitor. Use this flag to avoid a bandwidth penalty when an application expects to handle rotation. This option is only valid during full-screen mode. + + DXGI_SWAP_CHAIN_FLAG_NONPREROTATED + + + + Set this flag to enable an application to switch modes by calling . When switching from windowed to full-screen mode, the display mode (or monitor resolution) will be changed to match the dimensions of the application window. + + DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH + + + + Set this flag to enable an application to render using GDI on a swap chain or a surface. This will allow the application to call GetDC on the 0th back buffer or a surface. + + DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE + + + + None. + + None + + + + Identifies the type of DXGI adapter. + + + The DXGI_ADAPTER_FLAG enumerated type is used by the Flags member of the structure to identify the type of DXGI adapter. + + DXGI_ADAPTER_FLAG + + + + Specifies no flags. + + DXGI_ADAPTER_FLAG_NONE + + + + Value always set to 0. This flag is reserved. + + DXGI_ADAPTER_FLAG_REMOTE + + + + No documentation. + + DXGI_PRESENT_FLAGS + + + + No documentation. + + DXGI_PRESENT_TEST + + + + No documentation. + + DXGI_PRESENT_DO_NOT_SEQUENCE + + + + No documentation. + + DXGI_PRESENT_RESTART + + + + None. + + None + + + + No documentation. + + DXGI_RESOURCE_PRIORITY + + + + No documentation. + + DXGI_RESOURCE_PRIORITY_MINIMUM + + + + No documentation. + + DXGI_RESOURCE_PRIORITY_LOW + + + + No documentation. + + DXGI_RESOURCE_PRIORITY_NORMAL + + + + No documentation. + + DXGI_RESOURCE_PRIORITY_HIGH + + + + No documentation. + + DXGI_RESOURCE_PRIORITY_MAXIMUM + + + + No documentation. + + DXGI_MAP_FLAGS + + + + No documentation. + + DXGI_MAP_READ + + + + No documentation. + + DXGI_MAP_WRITE + + + + No documentation. + + DXGI_MAP_DISCARD + + + + No documentation. + + DXGI_ENUM_MODES_FLAGS + + + + No documentation. + + DXGI_ENUM_MODES_INTERLACED + + + + No documentation. + + DXGI_ENUM_MODES_SCALING + + + + No documentation. + + DXGI_MWA_FLAGS + + + + No documentation. + + DXGI_MWA_NO_WINDOW_CHANGES + + + + No documentation. + + DXGI_MWA_NO_ALT_ENTER + + + + No documentation. + + DXGI_MWA_NO_PRINT_SCREEN + + + + No documentation. + + DXGI_MWA_VALID + + + + None. + + None + + + + Flags indicating the method the raster uses to create an image on a surface. + + DXGI_MODE_SCANLINE_ORDER + + + + Scanline order is unspecified. + + DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED + + + + The image is created from the first scanline to the last without skipping any. + + DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE + + + + The image is created beginning with the upper field. + + DXGI_MODE_SCANLINE_ORDER_UPPER_FIELD_FIRST + + + + The image is created beginning with the lower field. + + DXGI_MODE_SCANLINE_ORDER_LOWER_FIELD_FIRST + + + + Flags indicating how an image is stretched to fit a given monitor's resolution. + + DXGI_MODE_SCALING + + + + Unspecified scaling. + + DXGI_MODE_SCALING_UNSPECIFIED + + + + Specifies no scaling. The image is centered on the display. This flag is typically used for a fixed-dot-pitch display (such as an LED display). + + DXGI_MODE_SCALING_CENTERED + + + + Specifies stretched scaling. + + DXGI_MODE_SCALING_STRETCHED + + + + Flags that indicate how the back buffers should be rotated to fit the physical rotation of a monitor. + + DXGI_MODE_ROTATION + + + + Unspecified rotation. + + DXGI_MODE_ROTATION_UNSPECIFIED + + + + Specifies no rotation. + + DXGI_MODE_ROTATION_IDENTITY + + + + Specifies 90 degrees of rotation. + + DXGI_MODE_ROTATION_ROTATE90 + + + + Specifies 180 degrees of rotation. + + DXGI_MODE_ROTATION_ROTATE180 + + + + Specifies 270 degrees of rotation. + + DXGI_MODE_ROTATION_ROTATE270 + + + + No documentation. + + DXGI_USAGE + + + + No documentation. + + DXGI_USAGE_SHADER_INPUT + + + + No documentation. + + DXGI_USAGE_RENDER_TARGET_OUTPUT + + + + No documentation. + + DXGI_USAGE_BACK_BUFFER + + + + No documentation. + + DXGI_USAGE_SHARED + + + + No documentation. + + DXGI_USAGE_READ_ONLY + + + + No documentation. + + DXGI_USAGE_DISCARD_ON_PRESENT + + + + No documentation. + + DXGI_USAGE_UNORDERED_ACCESS + + + + No documentation. + + DXGI_ERROR + + + + No documentation. + + DXGI_ERROR_INVALID_CALL + + + + No documentation. + + DXGI_ERROR_NOT_FOUND + + + + No documentation. + + DXGI_ERROR_MORE_DATA + + + + No documentation. + + DXGI_ERROR_UNSUPPORTED + + + + No documentation. + + DXGI_ERROR_DEVICE_REMOVED + + + + No documentation. + + DXGI_ERROR_DEVICE_HUNG + + + + No documentation. + + DXGI_ERROR_DEVICE_RESET + + + + No documentation. + + DXGI_ERROR_WAS_STILL_DRAWING + + + + No documentation. + + DXGI_ERROR_FRAME_STATISTICS_DISJOINT + + + + No documentation. + + DXGI_ERROR_GRAPHICS_VIDPN_SOURCE_IN_USE + + + + No documentation. + + DXGI_ERROR_DRIVER_INTERNAL_ERROR + + + + No documentation. + + DXGI_ERROR_NONEXCLUSIVE + + + + No documentation. + + DXGI_ERROR_NOT_CURRENTLY_AVAILABLE + + + + No documentation. + + DXGI_ERROR_REMOTE_CLIENT_DISCONNECTED + + + + No documentation. + + DXGI_ERROR_REMOTE_OUTOFMEMORY + + + + No documentation. + + DXGI_STATUS + + + + No documentation. + + DXGI_STATUS_OCCLUDED + + + + No documentation. + + DXGI_STATUS_CLIPPED + + + + No documentation. + + DXGI_STATUS_NO_REDIRECTION + + + + No documentation. + + DXGI_STATUS_NO_DESKTOP_ACCESS + + + + No documentation. + + DXGI_STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE + + + + No documentation. + + DXGI_STATUS_MODE_CHANGED + + + + No documentation. + + DXGI_STATUS_MODE_CHANGE_IN_PROGRESS + + + + Resource data formats which includes fully-typed and typeless formats. There is a list of format modifiers at the bottom of the page, that more fully describes each format type. + + + A few formats have additional restrictions. A resource declared with the DXGI_FORMAT_R32G32B32 family of formats cannot be used simultaneously for vertex and texture data. That is, you may not create a buffer resource with the DXGI_FORMAT_R32G32B32 family of formats that uses any of the following bind flags: D3D10_BIND_VERTEX_BUFFER, D3D10_BIND_INDEX_BUFFER, D3D10_BIND_CONSTANT_BUFFER, or D3D10_BIND_STREAM_OUTPUT (see ). DXGI_FORMAT_R1_UNORM is designed specifically for text filtering, and must be used with a format-specific, configurable 8x8 filter mode. When calling an HLSL sampling function using this format, the address offset parameter must be set to (0,0). A resource using a sub-sampled format (such as DXGI_FORMAT_R8G8_B8G8) must have a size that is a multiple of 2 in the x dimension. Format is not available in Direct3D 10 and Direct3D 10.1 Format Modifiers Each enumeration value contains a format modifier which describes the data type. Format ModifiersDescription _FLOATA floating-point value; 32-bit floating-point formats use IEEE 754 single-precision (s23e8 format): sign bit, 8-bit biased (127) exponent, and 23-bit mantissa. 16-bit floating-point formats use half-precision (s10e5 format): sign bit, 5-bit biased (15) exponent, and 10-bit mantissa. _SINTTwo's complement signed integer. For example, a 3-bit SINT represents the values -4, -3, -2, -1, 0, 1, 2, 3. _SNORMSigned normalized integer; which is interpreted in a resource as a signed integer, and is interpreted in a shader as a signed normalized floating-point value in the range [-1, 1]. For an 2's complement number, the maximum value is 1.0f (a 5-bit value 01111 maps to 1.0f), and the minimum value is -1.0f (a 5-bit value 10000 maps to -1.0f). In addition, the second-minimum number maps to -1.0f (a 5-bit value 10001 maps to -1.0f). The resulting integer representations are evenly spaced floating-point values in the range (-1.0f...0.0f), and also a complementary set of representations for numbers in the range (0.0f...1.0f). _SRGBStandard RGB data, which roughly displays colors in a linear ramp of luminosity levels such that an average observer, under average viewing conditions, can view them on an average display. All 0's maps to 0.0f, and all 1's maps to 1.0f. The sequence of unsigned integer encodings between all 0's and all 1's represent a nonlinear progression in the floating-point interpretation of the numbers between 0.0f to 1.0f. For more detail, see the SRGB color standard, IEC 61996-2-1, at IEC (International Electrotechnical Commission). Conversion to or from sRGB space is automatically done by D3DX10 or D3DX9 texture-load functions. If the format has an alpha channel, the alpha data is also stored in sRGB color space. _TYPELESSTypeless data, with a defined number of bits. Typeless formats are designed for creating typeless resources; that is, a resource whose size is known, but whose data type is not yet fully defined. When a typeless resource is bound to a shader, the application or shader must resolve the format type (which must match the number of bits per component in the typeless format). A typeless format contains one or more subformats; each subformat resolves the data type. For example, in the R32G32B32 group, which defines types for three-component 96-bit data, there is one typeless format and three fully typed subformats. + DXGI_FORMAT_R32G32B32_TYPELESS, DXGI_FORMAT_R32G32B32_FLOAT, DXGI_FORMAT_R32G32B32_UINT, DXGI_FORMAT_R32G32B32_SINT, + + _UINTUnsigned integer. For instance, a 3-bit UINT represents the values 0, 1, 2, 3, 4, 5, 6, 7. _UNORMUnsigned normalized integer; which is interpreted in a resource as an unsigned integer, and is interpreted in a shader as an unsigned normalized floating-point value in the range [0, 1]. All 0's maps to 0.0f, and all 1's maps to 1.0f. A sequence of evenly spaced floating-point values from 0.0f to 1.0f are represented. For instance, a 2-bit UNORM represents 0.0f, 1/3, 2/3, and 1.0f. ? New Resource Formats Direct3D 10 offers new data compression formats for compressing high-dynamic range (HDR) lighting data, normal maps and heightfields to a fraction of their original size. These compression types include: Shared-Exponent high-dynamic range (HDR) format (RGBE) New Block-Compressed 1-2 channel UNORM/SNORM formats The block compression formats can be used for any of the 2D or 3D texture types ( Texture2D, Texture2DArray, Texture3D, or TextureCube) including mipmap surfaces. The block compression techniques require texture dimensions to be a multiple of 4 (since the implementation compresses on blocks of 4x4 texels). In the texture sampler, compressed formats are always decompressed before texture filtering. + + DXGI_FORMAT + + + + The format is not known. + + DXGI_FORMAT_UNKNOWN + + + + A four-component, 128-bit typeless format. 1 + + DXGI_FORMAT_R32G32B32A32_TYPELESS + + + + A four-component, 128-bit floating-point format. 1 + + DXGI_FORMAT_R32G32B32A32_FLOAT + + + + A four-component, 128-bit unsigned-integer format. 1 + + DXGI_FORMAT_R32G32B32A32_UINT + + + + A four-component, 128-bit signed-integer format. 1 + + DXGI_FORMAT_R32G32B32A32_SINT + + + + A three-component, 96-bit typeless format. + + DXGI_FORMAT_R32G32B32_TYPELESS + + + + A three-component, 96-bit floating-point format. + + DXGI_FORMAT_R32G32B32_FLOAT + + + + A three-component, 96-bit unsigned-integer format. + + DXGI_FORMAT_R32G32B32_UINT + + + + A three-component, 96-bit signed-integer format. + + DXGI_FORMAT_R32G32B32_SINT + + + + A four-component, 64-bit typeless format. + + DXGI_FORMAT_R16G16B16A16_TYPELESS + + + + A four-component, 64-bit floating-point format. + + DXGI_FORMAT_R16G16B16A16_FLOAT + + + + A four-component, 64-bit unsigned-integer format. + + DXGI_FORMAT_R16G16B16A16_UNORM + + + + A four-component, 64-bit unsigned-integer format. + + DXGI_FORMAT_R16G16B16A16_UINT + + + + A four-component, 64-bit signed-integer format. + + DXGI_FORMAT_R16G16B16A16_SNORM + + + + A four-component, 64-bit signed-integer format. + + DXGI_FORMAT_R16G16B16A16_SINT + + + + A two-component, 64-bit typeless format. + + DXGI_FORMAT_R32G32_TYPELESS + + + + A two-component, 64-bit floating-point format. + + DXGI_FORMAT_R32G32_FLOAT + + + + A two-component, 64-bit unsigned-integer format. + + DXGI_FORMAT_R32G32_UINT + + + + A two-component, 64-bit signed-integer format. + + DXGI_FORMAT_R32G32_SINT + + + + A two-component, 64-bit typeless format. + + DXGI_FORMAT_R32G8X24_TYPELESS + + + + A 32-bit floating-point component, and two unsigned-integer components (with an additional 32 bits). + + DXGI_FORMAT_D32_FLOAT_S8X24_UINT + + + + A 32-bit floating-point component, and two typeless components (with an additional 32 bits). + + DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS + + + + A 32-bit typeless component, and two unsigned-integer components (with an additional 32 bits). + + DXGI_FORMAT_X32_TYPELESS_G8X24_UINT + + + + A four-component, 32-bit typeless format. + + DXGI_FORMAT_R10G10B10A2_TYPELESS + + + + A four-component, 32-bit unsigned-integer format. + + DXGI_FORMAT_R10G10B10A2_UNORM + + + + A four-component, 32-bit unsigned-integer format. + + DXGI_FORMAT_R10G10B10A2_UINT + + + + Three partial-precision floating-point numbers encodeded into a single 32-bit value (a variant of s10e5). There are no sign bits, and there is a 5-bit biased (15) exponent for each channel, 6-bit mantissa for R and G, and a 5-bit mantissa for B, as shown in the following illustration. + + DXGI_FORMAT_R11G11B10_FLOAT + + + + A three-component, 32-bit typeless format. + + DXGI_FORMAT_R8G8B8A8_TYPELESS + + + + A four-component, 32-bit unsigned-integer format. + + DXGI_FORMAT_R8G8B8A8_UNORM + + + + A four-component, 32-bit unsigned-normalized integer sRGB format. + + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB + + + + A four-component, 32-bit unsigned-integer format. + + DXGI_FORMAT_R8G8B8A8_UINT + + + + A three-component, 32-bit signed-integer format. + + DXGI_FORMAT_R8G8B8A8_SNORM + + + + A three-component, 32-bit signed-integer format. + + DXGI_FORMAT_R8G8B8A8_SINT + + + + A two-component, 32-bit typeless format. + + DXGI_FORMAT_R16G16_TYPELESS + + + + A two-component, 32-bit floating-point format. + + DXGI_FORMAT_R16G16_FLOAT + + + + A two-component, 32-bit unsigned-integer format. + + DXGI_FORMAT_R16G16_UNORM + + + + A two-component, 32-bit unsigned-integer format. + + DXGI_FORMAT_R16G16_UINT + + + + A two-component, 32-bit signed-integer format. + + DXGI_FORMAT_R16G16_SNORM + + + + A two-component, 32-bit signed-integer format. + + DXGI_FORMAT_R16G16_SINT + + + + A single-component, 32-bit typeless format. + + DXGI_FORMAT_R32_TYPELESS + + + + A single-component, 32-bit floating-point format. + + DXGI_FORMAT_D32_FLOAT + + + + A single-component, 32-bit floating-point format. + + DXGI_FORMAT_R32_FLOAT + + + + A single-component, 32-bit unsigned-integer format. + + DXGI_FORMAT_R32_UINT + + + + A single-component, 32-bit signed-integer format. + + DXGI_FORMAT_R32_SINT + + + + A two-component, 32-bit typeless format. + + DXGI_FORMAT_R24G8_TYPELESS + + + + A 32-bit z-buffer format that uses 24 bits for the depth channel and 8 bits for the stencil channel. + + DXGI_FORMAT_D24_UNORM_S8_UINT + + + + A 32-bit format, that contains a 24 bit, single-component, unsigned-normalized integer, with an additional typeless 8 bits. + + DXGI_FORMAT_R24_UNORM_X8_TYPELESS + + + + A 32-bit format, that contains a 24 bit, single-component, typeless format, with an additional 8 bit unsigned integer component. + + DXGI_FORMAT_X24_TYPELESS_G8_UINT + + + + A two-component, 16-bit typeless format. + + DXGI_FORMAT_R8G8_TYPELESS + + + + A two-component, 16-bit unsigned-integer format. + + DXGI_FORMAT_R8G8_UNORM + + + + A two-component, 16-bit unsigned-integer format. + + DXGI_FORMAT_R8G8_UINT + + + + A two-component, 16-bit signed-integer format. + + DXGI_FORMAT_R8G8_SNORM + + + + A two-component, 16-bit signed-integer format. + + DXGI_FORMAT_R8G8_SINT + + + + A single-component, 16-bit typeless format. + + DXGI_FORMAT_R16_TYPELESS + + + + A single-component, 16-bit floating-point format. + + DXGI_FORMAT_R16_FLOAT + + + + A single-component, 16-bit unsigned-normalized integer format. + + DXGI_FORMAT_D16_UNORM + + + + A single-component, 16-bit unsigned-integer format. + + DXGI_FORMAT_R16_UNORM + + + + A single-component, 16-bit unsigned-integer format. + + DXGI_FORMAT_R16_UINT + + + + A single-component, 16-bit signed-integer format. + + DXGI_FORMAT_R16_SNORM + + + + A single-component, 16-bit signed-integer format. + + DXGI_FORMAT_R16_SINT + + + + A single-component, 8-bit typeless format. + + DXGI_FORMAT_R8_TYPELESS + + + + A single-component, 8-bit unsigned-integer format. + + DXGI_FORMAT_R8_UNORM + + + + A single-component, 8-bit unsigned-integer format. + + DXGI_FORMAT_R8_UINT + + + + A single-component, 8-bit signed-integer format. + + DXGI_FORMAT_R8_SNORM + + + + A single-component, 8-bit signed-integer format. + + DXGI_FORMAT_R8_SINT + + + + A single-component, 8-bit unsigned-integer format. + + DXGI_FORMAT_A8_UNORM + + + + A single-component, 1-bit unsigned-normalized integer format. 2. + + DXGI_FORMAT_R1_UNORM + + + + Three partial-precision floating-point numbers encoded into a single 32-bit value all sharing the same 5-bit exponent (variant of s10e5). There is no sign bit, and there is a shared 5-bit biased (15) exponent and a 9-bit mantissa for each channel, as shown in the following illustration. 2. + + DXGI_FORMAT_R9G9B9E5_SHAREDEXP + + + + A four-component, 32-bit unsigned-normalized integer format. 3 + + DXGI_FORMAT_R8G8_B8G8_UNORM + + + + A four-component, 32-bit unsigned-normalized integer format. 3 + + DXGI_FORMAT_G8R8_G8B8_UNORM + + + + Four-component typeless block-compression format. + + DXGI_FORMAT_BC1_TYPELESS + + + + Four-component block-compression format. + + DXGI_FORMAT_BC1_UNORM + + + + Four-component block-compression format for sRGB data. + + DXGI_FORMAT_BC1_UNORM_SRGB + + + + Four-component typeless block-compression format. + + DXGI_FORMAT_BC2_TYPELESS + + + + Four-component block-compression format. + + DXGI_FORMAT_BC2_UNORM + + + + Four-component block-compression format for sRGB data. + + DXGI_FORMAT_BC2_UNORM_SRGB + + + + Four-component typeless block-compression format. + + DXGI_FORMAT_BC3_TYPELESS + + + + Four-component block-compression format. + + DXGI_FORMAT_BC3_UNORM + + + + Four-component block-compression format for sRGB data. + + DXGI_FORMAT_BC3_UNORM_SRGB + + + + One-component typeless block-compression format. + + DXGI_FORMAT_BC4_TYPELESS + + + + One-component block-compression format. + + DXGI_FORMAT_BC4_UNORM + + + + One-component block-compression format. + + DXGI_FORMAT_BC4_SNORM + + + + Two-component typeless block-compression format. + + DXGI_FORMAT_BC5_TYPELESS + + + + Two-component block-compression format. + + DXGI_FORMAT_BC5_UNORM + + + + Two-component block-compression format. + + DXGI_FORMAT_BC5_SNORM + + + + A three-component, 16-bit unsigned-normalized integer format. + + DXGI_FORMAT_B5G6R5_UNORM + + + + A four-component, 16-bit unsigned-normalized integer format that supports 1-bit alpha. + + DXGI_FORMAT_B5G5R5A1_UNORM + + + + A four-component, 32-bit unsigned-normalized integer format that supports 8-bit alpha. + + DXGI_FORMAT_B8G8R8A8_UNORM + + + + A four-component, 32-bit unsigned-normalized integer format. + + DXGI_FORMAT_B8G8R8X8_UNORM + + + + A four-component, 32-bit format that supports 2-bit alpha. 4 + + DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM + + + + A four-component, 32-bit typeless format that supports 8-bit alpha. 4 + + DXGI_FORMAT_B8G8R8A8_TYPELESS + + + + A four-component, 32-bit unsigned-normalized standard RGB format that supports 8-bit alpha. 4 + + DXGI_FORMAT_B8G8R8A8_UNORM_SRGB + + + + A four-component, 32-bit typeless format. 4 + + DXGI_FORMAT_B8G8R8X8_TYPELESS + + + + A four-component, 32-bit unsigned-normalized standard RGB format. 4 + + DXGI_FORMAT_B8G8R8X8_UNORM_SRGB + + + + A typeless block-compression format. 4 + + DXGI_FORMAT_BC6H_TYPELESS + + + + A block-compression format. 4 + + DXGI_FORMAT_BC6H_UF16 + + + + A block-compression format. 4 + + DXGI_FORMAT_BC6H_SF16 + + + + A typeless block-compression format. 4 + + DXGI_FORMAT_BC7_TYPELESS + + + + A block-compression format. 4 + + DXGI_FORMAT_BC7_UNORM + + + + A block-compression format. 4 + + DXGI_FORMAT_BC7_UNORM_SRGB + + + + DXGI Functions. + + + + + Load DLLs and bind functions + + + + + Creates a DXGI 1.0 factory that generates objects used to enumerate and specify video graphics settings. + + + Use a DXGI factory to generate objects that {{enumerate adapters}}, {{create swap chains}}, and {{associate a window}} with the alt+enter key sequence for toggling to and from the fullscreen display mode. Note??Do not mix the use of DXGI 1.0 () and DXGI 1.1 () in an application. Use IDXGIFactory or IDXGIFactory1, but not both in an application. + + The globally unique identifier (GUID) of the object referenced by the ppFactory parameter. + Address of a reference to an object. + Returns S_OK if successful; otherwise, returns one of the following . + HRESULT CreateDXGIFactory([None] GUID* riid,[Out] void** ppFactory) + + + + Creates a DXGI 1.1 factory that generates objects used to enumerate and specify video graphics settings. + + + Use a DXGI 1.1 factory to generate objects that {{enumerate adapters}}, {{create swap chains}}, and {{associate a window}} with the alt+enter key sequence for toggling to and from the full-screen display mode. This entry point is not supported by DXGI 1.0 shipped in Windows Vista and Windows Server 2008. DXGI 1.1 support is required which is available on Windows 7, Windows Server 2008 R2, and as an update to Windows Vista (KB971644). Note??Do not mix the use of DXGI 1.0 () and DXGI 1.1 () in an application. Use IDXGIFactory or IDXGIFactory1, but not both in an application. + + The globally unique identifier (GUID) of the object referenced by the ppFactory parameter. + Address of a reference to an object. + Returns S_OK if successful; an error code otherwise. For a list of error codes, see . + HRESULT CreateDXGIFactory1([None] GUID* riid,[Out] void** ppFactory) + + + + An IDXGIResource interface allows resource sharing and identifies the memory that a resource resides in. + + IDXGIResource + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the handle to a shared resource. The returned handle can be used to open the resource using different Direct3D devices. + + A reference to a handle. + Returns one of the following . + HRESULT IDXGIResource::GetSharedHandle([Out] void** pSharedHandle) + + + + Get the expected resource usage. + + A reference to a usage flag (see ). For Direct3D 10, a surface can be used as a shader input or a render-target output. + Returns one of the following . + HRESULT IDXGIResource::GetUsage([Out] DXGI_USAGE* pUsage) + + + + Set the priority for evicting the resource from memory. + + + The eviction priority is a memory-management variable that is used by DXGI for determining how to populate overcommitted memory. You can set priority levels other than the defined values when appropriate. For example, you can set a resource with a priority level of 0x78000001 to indicate that the resource is slightly above normal. + + The priority is one of the following values: ValueMeaning DXGI_RESOURCE_PRIORITY_MINIMUM (0x28000000) The resource is unused and can be evicted as soon as another resource requires the memory that the resource occupies. DXGI_RESOURCE_PRIORITY_LOW (0x50000000) The eviction priority of the resource is low. The placement of the resource is not critical, and minimal work is performed to find a location for the resource. For example, if a GPU can render with a vertex buffer from either local or non-local memory with little difference in performance, that vertex buffer is low priority. Other more critical resources (for example, a render target or texture) can then occupy the faster memory. DXGI_RESOURCE_PRIORITY_NORMAL (0x78000000) The eviction priority of the resource is normal. The placement of the resource is important, but not critical, for performance. The resource is placed in its preferred location instead of a low-priority resource. DXGI_RESOURCE_PRIORITY_HIGH (0xa0000000) The eviction priority of the resource is high. The resource is placed in its preferred location instead of a low-priority or normal-priority resource. DXGI_RESOURCE_PRIORITY_MAXIMUM (0xc8000000) The resource is evicted from memory only if there is no other way of resolving the memory requirement. ? + Returns one of the following . + HRESULT IDXGIResource::SetEvictionPriority([None] int EvictionPriority) + + + + Get the eviction priority. + + + The eviction priority is a memory-management variable that is used by DXGI to determine how to manage overcommitted memory. Priority levels other than the defined values are used when appropriate. For example, a resource with a priority level of 0x78000001 indicates that the resource is slightly above normal. + + A reference to the eviction priority, which determines when a resource can be evicted from memory. The following defined values are possible. ValueMeaning DXGI_RESOURCE_PRIORITY_MINIMUM (0x28000000) The resource is unused and can be evicted as soon as another resource requires the memory that the resource occupies. DXGI_RESOURCE_PRIORITY_LOW (0x50000000) The eviction priority of the resource is low. The placement of the resource is not critical, and minimal work is performed to find a location for the resource. For example, if a GPU can render with a vertex buffer from either local or non-local memory with little difference in performance, that vertex buffer is low priority. Other more critical resources (for example, a render target or texture) can then occupy the faster memory. DXGI_RESOURCE_PRIORITY_NORMAL (0x78000000) The eviction priority of the resource is normal. The placement of the resource is important, but not critical, for performance. The resource is placed in its preferred location instead of a low-priority resource. DXGI_RESOURCE_PRIORITY_HIGH (0xa0000000) The eviction priority of the resource is high. The resource is placed in its preferred location instead of a low-priority or normal-priority resource. DXGI_RESOURCE_PRIORITY_MAXIMUM (0xc8000000) The resource is evicted from memory only if there is no other way of resolving the memory requirement. ? + Returns one of the following . + HRESULT IDXGIResource::GetEvictionPriority([Out] int* pEvictionPriority) + + + + Get the handle to a shared resource. The returned handle can be used to open the resource using different Direct3D devices. + + HRESULT IDXGIResource::GetSharedHandle([Out] void** pSharedHandle) + + + + Get the expected resource usage. + + HRESULT IDXGIResource::GetUsage([Out] DXGI_USAGE* pUsage) + + + + Get the eviction priority. + + + The eviction priority is a memory-management variable that is used by DXGI to determine how to manage overcommitted memory. Priority levels other than the defined values are used when appropriate. For example, a resource with a priority level of 0x78000001 indicates that the resource is slightly above normal. + + HRESULT IDXGIResource::GetEvictionPriority([Out] int* pEvictionPriority) + + + + Represents a keyed mutex, which allows exclusive access to a shared resource that is used by multiple devices. + + IDXGIKeyedMutex + + + + Initializes a new instance of the class. + + The native pointer. + + + + Using a key, acquires exclusive rendering access to a shared resource. + + + The AcquireSync method creates a lock to a surface that is shared between multiple devices, allowing only one device to render to a surface at a time. This method uses a key to determine which device currently has exclusive access to the surface. When a surface is created using the D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX value of the enumeration, you must call the AcquireSync method before rendering to the surface. You must call the {{ReleaseSync}} method when you are done rendering to a surface. To acquire a reference to the keyed mutex object of a shared resource, call the {{QueryInterface}} method of the resource and pass in the UUID of the interface. For more information about acquiring this reference, see the following code example. The AcquireSync method uses the key as follows, depending on the state of the surface: On initial creation, the surface is unowned and any device can call the AcquireSync method to gain access. For an unowned device, only a key of 0 will succeed. Calling the AcquireSync method for any other key will stall the calling CPU thread. If the surface is owned by a device when you call the AcquireSync method, the CPU thread that called the AcquireSync method will stall until the owning device calls the {{ReleaseSync}} method using the same Key. If the surface is unowned when you call the AcquireSync method (for example, the last owning device has already called the {{ReleaseSync}} method), the AcquireSync method will succeed if you specify the same key that was specified when the ReleaseSync method was last called. Calling the AcquireSync method using any other key will cause a stall. When the owning device calls the {{ReleaseSync}} method with a particular key, and more than one device is waiting after calling the AcquireSync method using the same key, any one of the waiting devices could be woken up first. The order in which devices are woken up is undefined. A keyed mutex does not support recursive calls to the AcquireSync method. + + A value that indicates which device to give access to. This method will succeed when the device that currently owns the surface calls the method using the same value. This value can be any UINT64 value. + The time-out interval, in milliseconds. This method will return if the interval elapses, and the keyed mutex has not been released using the specified Key. If this value is set to zero, the AcquireSync method will test to see if the keyed mutex has been released and returns immediately. If this value is set to INFINITE, the time-out interval will never elapse. + Return S_OK if successful. If the owning device attempted to create another keyed mutex on the same shared resource, AcquireSync returns E_FAIL. AcquireSync can also return the following {{DWORD}} constants. Therefore, you should explicitly check for these constants. If you only use the {{SUCCEEDED}} macro on the return value to determine if AcquireSync succeeded, you will not catch these constants. WAIT_ABANDONED - The shared surface and keyed mutex are no longer in a consistent state. If AcquireSync returns this value, you should release and recreate both the keyed mutex and the shared surface. WAIT_TIMEOUT - The time-out interval elapsed before the specified key was released. + HRESULT IDXGIKeyedMutex::AcquireSync([None] __int64 Key,[None] int dwMilliseconds) + + + + Using a key, releases exclusive rendering access to a shared resource. + + + The ReleaseSync method releases a lock to a surface that is shared between multiple devices. This method uses a key to determine which device currently has exclusive access to the surface. When a surface is created using the D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX value of the enumeration, you must call the method before rendering to the surface. You must call the ReleaseSync method when you are done rendering to a surface. After you call the ReleaseSync method, the shared resource is unset from the rendering pipeline. To acquire a reference to the keyed mutex object of a shared resource, call the {{QueryInterface}} method of the resource and pass in the UUID of the interface. For more information about acquiring this reference, see the following code example. + + A value that indicates which device to give access to. This method succeeds when the device that currently owns the surface calls the ReleaseSync method using the same value. This value can be any UINT64 value. + Returns S_OK if successful. If the device attempted to release a keyed mutex that is not valid or owned by the device, ReleaseSync returns E_FAIL. + HRESULT IDXGIKeyedMutex::ReleaseSync([None] __int64 Key) + + + + An IDXGISurface interface implements methods for image-data objects. + + IDXGISurface + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a description of the surface. + + A reference to the surface description (see ). + Returns one of the following . + HRESULT IDXGISurface::GetDesc([Out] DXGI_SURFACE_DESC* pDesc) + + + + Get a reference to the data contained in the surface, and deny GPU access to the surface. + + + Use IDXGISurface::Map to access a surface from the CPU. To release a mapped surface (and allow GPU access) call . + + A reference to the surface data (see ). + CPU read-write flags. These flags can be combined with a logical OR. DXGI_MAP_READ - Allow CPU read access. DXGI_MAP_WRITE - Allow CPU write access. DXGI_MAP_DISCARD - Discard the previous contents of a resource when it is mapped. + Returns one of the following . + HRESULT IDXGISurface::Map([Out] DXGI_MAPPED_RECT* pLockedRect,[None] int MapFlags) + + + + Invalidate the reference to the surface retrieved by and re-enable GPU access to the resource. + + Returns one of the following . + HRESULT IDXGISurface::Unmap() + + + + Acquires access to the surface data. + + Flags specifying CPU access permissions. + A for accessing the mapped data, or null on failure.. + + + + Gets a swap chain back buffer. + + The swap chain to get the buffer from. + The index of the desired buffer. + The buffer interface, or null on failure. + + + + Get a description of the surface. + + HRESULT IDXGISurface::GetDesc([Out] DXGI_SURFACE_DESC* pDesc) + + + + The IDXGISurface1 interface extends the by adding support for rendering to a DXGI interface using GDI. + + IDXGISurface1 + + + + Initializes a new instance of the class. + + The native pointer. + + + + Returns a device context (DC) that allows you to render to a DXGI surface using GDI. + + + After you use the GetDC method to retrieve a DC, you can render to the DXGI surface using GDI. The GetDC method readies the surface for GDI rendering and allows interoperation between DXGI and GDI technologies. Keep the following in mind when using this method: You must create the surface using the D3D10_RESOURCE_MISC_GDI_COMPATIBLE flag for a surface or use the DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE flag for swap chains, otherwise this method will fail. You must release the device and call the method before issuing any new Direct3D commands. This method will fail if an outstanding DC has already been created by this method. The format for the surface or swapchain must DXGI_FORMAT_B8G8R8A8_UNORM_SRGB or DXGI_FORMAT_B8G8R8A8_UNORM On GetDC, the render targer in the output merger of the Direct3D pipeline is unbound from the surface. OMSetRenderTargets must be called on the device prior to Direct3D rendering after GDI rendering. Prior to resizing buffers you must release all outstanding DCs. GetDC can also be called on the back buffer at index 0 of a swap chain by obtaining an from the Swap Chain. The following code illustrates the process. + IDXGISwapChain* g_pSwapChain = NULL; + IDXGISurface1* g_pSurface1 = NULL; + ... + //Setup the device and and swapchain + g_pSwapChain->GetBuffer(0, __uuidof(IDXGISurface1), (void**) &g_pSurface1); + g_pSurface1->GetDC( FALSE, &g_hDC ); + ... + //Draw on the DC using GDI + ... + //When finish drawing release the DC + g_pSurface1->ReleaseDC( NULL ); + + + + If true the application will not preserve any rendering with GDI; otherwise, false. If false, any previous rendering to the device context will be preserved. This flag is ideal for simply reading the device context and not doing any rendering to the surface. + A reference to an {{HDC}} handle that represents the current device context for GDI rendering. + HRESULT IDXGISurface1::GetDC([None] BOOL Discard,[Out] void** phdc) + + + + Releases the GDI device context (DC) associated with the current surface and allows rendering using Direct3D. + + + Use the ReleaseDC method to release the DC and indicate that your application has finished all GDI rendering to this surface. You must call the ReleaseDC method before you perform addition rendering using Direct3D. Prior to resizing buffers all outstanding DCs must be released. + + A reference to a RECT structure that identifies the dirty region of the surface. A dirty region is any part of the surface that you have used for GDI rendering and that you want to preserve. This is used as a performance hint to graphics subsystem in certain scenarios. Do not use this parameter to restrict rendering to the specified rectangular region. Passing in NULL causes the whole surface to be considered dirty. Otherwise the area specified by the RECT will be used as a performance hint to indicate what areas have been manipulated by GDI rendering. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDXGISurface1::ReleaseDC([In, Optional] RECT* pDirtyRect) + + + + Releases the GDI device context (DC) associated with the current surface and allows rendering using Direct3D. The whole surface to be considered dirty. + + + Use the ReleaseDC method to release the DC and indicate that your application has finished all GDI rendering to this surface. You must call the ReleaseDC method before you perform addition rendering using Direct3D. Prior to resizing buffers all outstanding DCs must be released. + + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDXGISurface1::ReleaseDC([In, Optional] RECT* pDirtyRect) + + + + Releases the GDI device context (DC) associated with the current surface and allows rendering using Direct3D. + + + Use the ReleaseDC method to release the DC and indicate that your application has finished all GDI rendering to this surface. You must call the ReleaseDC method before you perform addition rendering using Direct3D. Prior to resizing buffers all outstanding DCs must be released. + + A reference to a structure that identifies the dirty region of the surface. A dirty region is any part of the surface that you have used for GDI rendering and that you want to preserve. This is used as a performance hint to graphics subsystem in certain scenarios. Do not use this parameter to restrict rendering to the specified rectangular region. The area specified by the will be used as a performance hint to indicate what areas have been manipulated by GDI rendering. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDXGISurface1::ReleaseDC([In, Optional] RECT* pDirtyRect) + + + + An IDXGIOutput interface represents an adapter output (such as a monitor). + + IDXGIOutput + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a description of the output. + + A reference to the output description (see ). + Returns a code that indicates success or failure. S_OK if successful, if pDesc is passed in as NULL. + HRESULT IDXGIOutput::GetDesc([Out] DXGI_OUTPUT_DESC* pDesc) + + + + Gets the display modes that match the requested format and other input options. + + + In general, when switching from windowed to full-screen mode, a swap chain automatically chooses a display mode that meets (or exceeds) the resolution, color depth and refresh rate of the swap chain. To exercise more control over the display mode, use this API to poll the set of display modes that are validated against monitor capabilities, or all modes that match the desktop (if the desktop settings are not validated against the monitor). As shown, this API is designed to be called twice. First to get the number of modes available, and second to return a description of the modes. + UINT num = 0; + DXGI_FORMAT format = DXGI_FORMAT_R32G32B32A32_FLOAT; + UINT flags = DXGI_ENUM_MODES_INTERLACED; pOutput->GetDisplayModeList( format, flags, &num, 0); ... DXGI_MODE_DESC * pDescs = new DXGI_MODE_DESC[num]; + pOutput->GetDisplayModeList( format, flags, &num, pDescs); + + + + The color format (see ). + Options for modes to include (see {{DXGI_ENUM_MODES}}). DXGI_ENUM_MODES_SCALING needs to be specified to expose the display modes that require scaling. Centered modes, requiring no scaling and corresponding directly to the display output, are enumerated by default. + Set pDesc to NULL so that pNumModes returns the number of display modes that match the format and the options. Otherwise, pNumModes returns the number of display modes returned in pDesc. + A reference to a list of display modes (see ); set to NULL to get the number of display modes. + Returns one of the following . It is rare, but possible, that the display modes available can change immediately after calling this method, in which case DXGI_ERROR_MORE_DATA is returned (if there is not enough room for all the display modes). If GetDisplayModeList is called from a Remote Desktop Services session (formerly Terminal Services session), DXGI_ERROR_NOT_CURRENTLY_AVAILABLE is returned. + HRESULT IDXGIOutput::GetDisplayModeList([None] DXGI_FORMAT EnumFormat,[None] int Flags,[InOut] int* pNumModes,[Out, Buffer, Optional] DXGI_MODE_DESC* pDesc) + + + + Find the display mode that most closely matches the requested display mode. + + + Direct3D devices require UNORM formats. This method finds the closest matching available display mode to the mode specified in pModeToMatch. Similarly ranked fields (ie. all specified, or all unspecified, etc) are resolved in the following order. ScanlineOrdering Scaling Format Resolution RefreshRate When determining the closest value for a particular field, previously matched fields are used to filter the display mode list choices, and other fields are ignored. For example, when matching Resolution, the display mode list will have already been filtered by a certain ScanlineOrdering, Scaling, and Format, while RefreshRate is ignored. This ordering doesn't define the absolute ordering for every usage scenario of FindClosestMatchingMode, because the application can choose some values initially, effectively changing the order that fields are chosen. Fields of the display mode are matched one at a time, generally in a specified order. If a field is unspecified, FindClosestMatchingMode gravitates toward the values for the desktop related to this output. If this output is not part of the desktop, then the default desktop output is used to find values. If an application uses a fully unspecified display mode, FindClosestMatchingMode will typically return a display mode that matches the desktop settings for this output. Unspecified fields are lower priority than specified fields and will be resolved later than specified fields. + + The desired display mode (see ). Members of DXGI_MODE_DESC can be unspecified indicating no preference for that member. A value of 0 for Width or Height indicates the value is unspecified. If either Width or Height are 0 both must be 0. A numerator and denominator of 0 in RefreshRate indicate it is unspecified. Other members of DXGI_MODE_DESC have enumeration values indicating the member is unspecified. If pConnectedDevice is NULL Format cannot be DXGI_FORMAT_UNKNOWN. + The mode that most closely matches pModeToMatch. + A reference to the Direct3D device interface. If this parameter is NULL, only modes whose format matches that of pModeToMatch will be returned; otherwise, only those formats that are supported for scan-out by the device are returned. + Returns one of the following . + HRESULT IDXGIOutput::FindClosestMatchingMode([In] const DXGI_MODE_DESC* pModeToMatch,[Out] DXGI_MODE_DESC* pClosestMatch,[In, Optional] IUnknown* pConcernedDevice) + + + + Halt a thread until the next vertical blank occurs. + + + A vertical blank occurs when the raster moves from the lower right corner to the upper left corner to begin drawing the next frame. + + Returns one of the following . + HRESULT IDXGIOutput::WaitForVBlank() + + + + Take ownership of an output. + + + When you are finished with the output, call . This method should not be called directly by applications, since results will be unpredictable. It is called implicitly by the DXGI swap chain object during fullscreen transitions, and should not be used as a substitute for swap chain methods. + + A reference to the IUnknown interface of a device (such as an ). + Set to TRUE to enable other threads or applications to take ownership of the device; otherwise set to FALSE. + Returns one of the following . + HRESULT IDXGIOutput::TakeOwnership([In] IUnknown* pDevice,[None] BOOL Exclusive) + + + + Release ownership of the output. + + + If you are not using a swap chain, get access to an output by calling and release it when you are finished by calling IDXGIOutput::ReleaseOwnership. An application that uses a swap chain will typically not call either of these methods. + + void IDXGIOutput::ReleaseOwnership() + + + + Get a description of the gamma-control capabilities. + + + Note??Calling this method is only supported while in full-screen mode. + + A description of the gamma-control capabilities (see ). + Returns one of the following . + HRESULT IDXGIOutput::GetGammaControlCapabilities([Out] DXGI_GAMMA_CONTROL_CAPABILITIES* pGammaCaps) + + + + Set the gamma controls. + + + Note??Calling this method is only supported while in full-screen mode. + + A reference to an array of gamma controls (see ). + Returns one of the following . + HRESULT IDXGIOutput::SetGammaControl([In] const DXGI_GAMMA_CONTROL* pArray) + + + + Get the gamma control settings. + + + Note??Calling this method is only supported while in full-screen mode. + + An array of gamma control settings (see ). + Returns one of the following . + HRESULT IDXGIOutput::GetGammaControl([Out] DXGI_GAMMA_CONTROL* pArray) + + + + Change the display mode. + + + IDXGIOutput::SetDisplaySurface should not be called directly by applications, since results will be unpredictable. It is called implicitly by the DXGI swap chain object during fullscreen transitions, and should not be used as a substitute for swap-chain methods. This method should only be called between and calls. + + A reference to a surface (see ) used for rendering an image to the screen. The surface must have been created with as a back buffer (DXGI_USAGE_BACKBUFFER). + Returns one of the following . + HRESULT IDXGIOutput::SetDisplaySurface([In] IDXGISurface* pScanoutSurface) + + + + Get a copy of the current display surface. + + + IDXGIOutput::GetDisplaySurfaceData can only be called when an output is in full-screen mode. If the method succeeds, the destination surface will be filled. Use to find out the size (width and height) when allocating space for the destination surface. This is true regardless of target monitor rotation. A destination surface created by a graphics component (such as Direct3D 10) must be created with CPU-write permission (see D3D10_CPU_ACCESS_WRITE). Other surfaces should be created with CPU read-write permission (see D3D10_CPU_ACCESS_READ_WRITE). This method will modify the surface data to fit the destination surface (stretch, shrink, convert format, rotate). The stretch and shrink is performed with point-sampling. + + A reference to a destination surface (see ). + Returns one of the following . + HRESULT IDXGIOutput::GetDisplaySurfaceData([In] IDXGISurface* pDestination) + + + + Get statistics about recently rendered frames. + + + This API is similar to . Note??Calling this method is only supported while in full-screen mode. + + A reference to a frame statictics (see ). + If this function succeeds, it will return S_OK. Otherwise, it may return . + HRESULT IDXGIOutput::GetFrameStatistics([Out] DXGI_FRAME_STATISTICS* pStats) + + + + Find the display mode that most closely matches the requested display mode. + + + Direct3D devices require UNORM formats. This method finds the closest matching available display mode to the mode specified in pModeToMatch. Similarly ranked fields (ie. all specified, or all unspecified, etc) are resolved in the following order. ScanlineOrdering Scaling Format Resolution RefreshRate When determining the closest value for a particular field, previously matched fields are used to filter the display mode list choices, and other fields are ignored. For example, when matching Resolution, the display mode list will have already been filtered by a certain ScanlineOrdering, Scaling, and Format, while RefreshRate is ignored. This ordering doesn't define the absolute ordering for every usage scenario of FindClosestMatchingMode, because the application can choose some values initially, effectively changing the order that fields are chosen. Fields of the display mode are matched one at a time, generally in a specified order. If a field is unspecified, FindClosestMatchingMode gravitates toward the values for the desktop related to this output. If this output is not part of the desktop, then the default desktop output is used to find values. If an application uses a fully unspecified display mode, FindClosestMatchingMode will typically return a display mode that matches the desktop settings for this output. Unspecified fields are lower priority than specified fields and will be resolved later than specified fields. + + A reference to the Direct3D device interface. If this parameter is NULL, only modes whose format matches that of pModeToMatch will be returned; otherwise, only those formats that are supported for scan-out by the device are returned. + The desired display mode (see ). Members of DXGI_MODE_DESC can be unspecified indicating no preference for that member. A value of 0 for Width or Height indicates the value is unspecified. If either Width or Height are 0 both must be 0. A numerator and denominator of 0 in RefreshRate indicate it is unspecified. Other members of DXGI_MODE_DESC have enumeration values indicating the member is unspecified. If pConnectedDevice is NULL Format cannot be DXGI_FORMAT_UNKNOWN. + The mode that most closely matches pModeToMatch. + Returns one of the following . + HRESULT IDXGIOutput::FindClosestMatchingMode([In] const DXGI_MODE_DESC* pModeToMatch,[Out] DXGI_MODE_DESC* pClosestMatch,[In, Optional] IUnknown* pConcernedDevice) + + + + Gets the display modes that match the requested format and other input options. + + + In general, when switching from windowed to full-screen mode, a swap chain automatically chooses a display mode that meets (or exceeds) the resolution, color depth and refresh rate of the swap chain. To exercise more control over the display mode, use this API to poll the set of display modes that are validated against monitor capabilities, or all modes that match the desktop (if the desktop settings are not validated against the monitor). As shown, this API is designed to be called twice. First to get the number of modes available, and second to return a description of the modes. + UINT num = 0; + DXGI_FORMAT format = DXGI_FORMAT_R32G32B32A32_FLOAT; + UINT flags = DXGI_ENUM_MODES_INTERLACED; pOutput->GetDisplayModeList( format, flags, &num, 0); ... DXGI_MODE_DESC * pDescs = new DXGI_MODE_DESC[num]; + pOutput->GetDisplayModeList( format, flags, &num, pDescs); + + + + The color format (see ). + format for modes to include (see {{DXGI_ENUM_MODES}}). DXGI_ENUM_MODES_SCALING needs to be specified to expose the display modes that require scaling. Centered modes, requiring no scaling and corresponding directly to the display output, are enumerated by default. + Returns a list of display modes (see ); + HRESULT IDXGIOutput::GetDisplayModeList([None] DXGI_FORMAT EnumFormat,[None] int Flags,[InOut] int* pNumModes,[Out, Buffer, Optional] DXGI_MODE_DESC* pDesc) + + + + Get a description of the output. + + HRESULT IDXGIOutput::GetDesc([Out] DXGI_OUTPUT_DESC* pDesc) + + + + Get a description of the gamma-control capabilities. + + + Note??Calling this method is only supported while in full-screen mode. + + HRESULT IDXGIOutput::GetGammaControlCapabilities([Out] DXGI_GAMMA_CONTROL_CAPABILITIES* pGammaCaps) + + + + Get the gamma control settings. + + + Note??Calling this method is only supported while in full-screen mode. + + HRESULT IDXGIOutput::GetGammaControl([Out] DXGI_GAMMA_CONTROL* pArray) + + + + Get statistics about recently rendered frames. + + + This API is similar to . Note??Calling this method is only supported while in full-screen mode. + + HRESULT IDXGIOutput::GetFrameStatistics([Out] DXGI_FRAME_STATISTICS* pStats) + + + + An IDXGISwapChain interface implements one or more {{surfaces}} for storing rendered data before presenting it to an output. + + IDXGISwapChain + + + + Initializes a new instance of the class. + + The native pointer. + + + + Present a rendered image to the user. + + + For the best performance when flipping swap-chain buffers in full-screen application, see {{Full-Screen Application Performance Hints}}. Because calling Present may cause the render thread to wait on the message-pump thread care should be taken when calling this method in an application that uses multiple threads. For more details, see {{Multithreading Considerations}}. Differences between Direct3D 9 and Direct3D 10: Specifying DXGI_PRESENT_TEST in the Flags parameter is analogous to IDirect3DDevice9::TestCooperativeLevel in D3D9. ? + + An integer that specifies the how to synchronize presentation of a frame with the vertical blank. Values are: 0 - The presentation occurs immediately, there is no synchronization. 1,2,3,4 - Synchronize presentation after the n'th vertical blank. If the update region straddles more than one output (each represented by ), the synchronization will be performed to the output that contains the largest subrectangle of the target window's client area. + An integer value that contains swap-chain presentation options (see {{DXGI_PRESENT}}). + Possible return values include: S_OK, DXGI_ERROR_DEVICE_RESET or DXGI_ERROR_DEVICE_REMOVED (see ), DXGI_STATUS_OCCLUDED (see ), or D3DDDIERR_DEVICEREMOVED. Note that the Present method can return either DXGI_ERROR_DEVICE_REMOVED or D3DDDIERR_DEVICEREMOVED if a video card has been physically removed from the system, or a driver upgrade for the video card has occurred. + HRESULT IDXGISwapChain::Present([None] int SyncInterval,[None] DXGI_PRESENT_FLAGS Flags) + + + + Access one of the swap-chain back buffers. + + + Here is an example. + ID3D10Texture2D * p_RT; ... // Get the surface from the swap chain pSwapChain->GetBuffer(0, __uuidof(p_RT), reinterpret_cast<void**>(&p_RT)); + + + + A zero-based buffer index. If the swap effect is not DXGI_SWAP_EFFECT_SEQUENTIAL, this method only has access to the first buffer; for this case, set the index to zero. + The type of interface used to manipulate the buffer. See remarks. + A reference to a back-buffer interface. + Returns one of the following . + HRESULT IDXGISwapChain::GetBuffer([None] int Buffer,[In] GUID* riid,[Out] void** ppSurface) + + + + Sets the display state to windowed or full-screen. + + + DXGI may change the display state of a swap chain is response to user or system requests. + + Use TRUE for full-screen, FALSE for windowed. + If you pass TRUE to the Fullscreen parameter to set the display state to full-screen, you can optionally set this parameter to the output target (see ) that contains the swap chain. If you set this parameter to NULL, DXGI will choose the output based on the swap-chain's device and the output window's placement. If you pass FALSE to Fullscreen, you must set this parameter to NULL. + This methods returns: S_OK if the action succeeded and the swap chain was placed in the requested state. DXGI_ERROR_NOT_CURRENTLY_AVAILABLE if the action failed. There are many reasons why a windowed-mode swap chain cannot switch to full-screen mode. For instance: The application is running over Terminal Server. The output window is occluded. The output window does not have keyboard focus. Another application is already in full-screen mode. When this error is returned, an application can continue to run in windowed mode and try to switch to full-screen mode later. DXGI_STATUS_MODE_CHANGE_IN_PROGRESS is returned if a fullscreen/windowed mode transition is occurring when this API is called. Other error codes if you run out of memory or encounter another unexpected fault; these codes may be treated as hard, non-continuable errors. + HRESULT IDXGISwapChain::SetFullscreenState([None] BOOL Fullscreen,[In, Optional] IDXGIOutput* pTarget) + + + + Get the state associated with full-screen mode. + + + When the swap chain is in full-screen mode, a reference to the target output will be returned and its reference count will be incremented. + + A reference to a boolean whose value is either: TRUE if the swap chain is in full-screen mode FALSE if the swap chain is in windowed mode + A reference to the output target (see ) when the mode is full screen; otherwise NULL. + Returns one of the following . + HRESULT IDXGISwapChain::GetFullscreenState([Out] BOOL* pFullscreen,[Out] IDXGIOutput** ppTarget) + + + + Get a description of the swap chain. + + A reference to the swap-chain description (see ). + Returns one of the following . + HRESULT IDXGISwapChain::GetDesc([Out] DXGI_SWAP_CHAIN_DESC* pDesc) + + + + Change the swap chain's back buffer size, format, and number of buffers. This should be called when the application window is resized. + + + A swapchain cannot be resized unless all outstanding references to its back buffers have been released. The application must release all of its direct and indirect references on the backbuffers in order for ResizeBuffers to succeed. Direct references are held by the application after calling AddRef on a resource. Indirect references are held by views to a resource, binding a view of the resource to a device context, a command list that used the resource, a command list that used a view to that resource, a command list that executed another command list that used the resource, etc. Before calling ResizeBuffers, ensure that the application releases all references (by calling the appropriate number of Release invocations) on the resources, any views to the resource, any command lists that use either the resources or views, and ensure that neither the resource, nor a view is still bound to a device context. ClearState can be used to ensure this. If a view is bound to a deferred context, then the partially built command list must be discarded as well (by calling ClearState, FinishCommandList, then Release on the command list). The application can re-query interfaces after calling ResizeBuffers via . This method should be called whenever a client window is resized. It is recommended to call this API when an application receives a WM_SIZE message. + + The number of buffers in the swap chain (including all back and front buffers). This can be different from the number of buffers the swap chain was created with. + New width of the back buffer. If 0 is specified the width of the client area of the target window will be used. + New height of the back buffer. If 0 is specified the height of the client area of the target window will be used. + The new format of the back buffer. See . + Flags that indicate how the swap chain will function. See . + Returns one of the following . + HRESULT IDXGISwapChain::ResizeBuffers([None] int BufferCount,[None] int Width,[None] int Height,[None] DXGI_FORMAT NewFormat,[None] int SwapChainFlags) + + + + Resize the output target. + + + This function resizes the target window when the swap chain is in windowed mode, and changes the display mode on the target output when the swap chain is in full-screen mode. Therefore, applications can call this method to resize the target window (rather than a win32 API such as SetWindowPos) without knowledge of the swap chain display mode. + + A reference to the mode description (see ), which specifies the new width, height, format and refresh rate of the target. If the format is DXGI_FORMAT_UNKNOWN, the existing format will be used. Using DXGI_FORMAT_UNKNOWN is only recommended when the swap chain is in full-screen mode as this method is not thread safe. + Returns a code that indicates success or failure. DXGI_STATUS_MODE_CHANGE_IN_PROGRESS is returned if a fullscreen/windowed mode transition is occurring when this API is called. See for additional DXGI error codes. + HRESULT IDXGISwapChain::ResizeTarget([In] const DXGI_MODE_DESC* pNewTargetParameters) + + + + Get the output (the display monitor) that contains the majority of the client area of the target window. + + + If the method succeeds, the output interface will be filled and its reference count incremented. When you are finished with it, be sure to release the interface to avoid a memory leak. The output is also owned by the adapter on which the swap chain's device was created. + + A reference to the output interface (see ). + Returns one of the following . + HRESULT IDXGISwapChain::GetContainingOutput([Out] IDXGIOutput** ppOutput) + + + + Get performance statistics about the last render frame. + + + This method is not supported when the swap chain is windowed. + + A reference to the frame statistics (see ). + Returns one of the following . + HRESULT IDXGISwapChain::GetFrameStatistics([Out] DXGI_FRAME_STATISTICS* pStats) + + + + Get the number of times has been called. + + A reference to the number of calls. + Returns one of the following . + HRESULT IDXGISwapChain::GetLastPresentCount([Out] int* pLastPresentCount) + + + + Creates a swap chain. + + + If you attempt to create a swap chain in full-screen mode, and full-screen mode is unavailable, the swap chain will be created in windowed mode and DXGI_STATUS_OCCLUDED will be returned. If the buffer width or the buffer height are zero, the sizes will be inferred from the output window size in the swap-chain description. Since the target output cannot be chosen explicitly when the swap-chain is created, you should not create a full-screen swap chain. This can reduce presentation performance if the swap chain size and the output window size do not match. Here are two ways to ensure the sizes match: Create a windowed swap chain and then set it full-screen using . Save a reference to the swap-chain immediately after creation, and use it to get the output window size during a WM_SIZE event. Then resize the swap chain buffers (with ) during the transition from windowed to full-screen. If the swap chain is in full-screen mode, before you release it, you must use {{SetFullscreenState}} to switch it to windowed mode. For more information about releasing a swap chain, see the Destroying a Swap Chain section of {{DXGI Overview}}. + + a reference to a . + A reference to the device that will write 2D images to the swap chain. + A reference to the swap-chain description (see ). + HRESULT IDXGIFactory::CreateSwapChain([In] IUnknown* pDevice,[In] DXGI_SWAP_CHAIN_DESC* pDesc,[Out] IDXGISwapChain** ppSwapChain) + + + + Access one of the swap-chain back buffers. + + The interface of the surface to resolve from the back buffer + A zero-based buffer index. If the swap effect is not DXGI_SWAP_EFFECT_SEQUENTIAL, this method only has access to the first buffer; for this case, set the index to zero. + + Returns a reference to a back-buffer interface. + + HRESULT IDXGISwapChain::GetBuffer([None] int Buffer,[In] GUID* riid,[Out] void** ppSurface) + + + + Get the state associated with full-screen mode. + + + When the swap chain is in full-screen mode, a reference to the target output will be returned and its reference count will be incremented. + + A reference to a boolean whose value is either: TRUE if the swap chain is in full-screen mode FALSE if the swap chain is in windowed mode + A reference to the output target (see ) when the mode is full screen; otherwise NULL. + Returns one of the following . + HRESULT IDXGISwapChain::GetFullscreenState([Out] BOOL* pFullscreen,[Out] IDXGIOutput** ppTarget) + + + + Get a description of the swap chain. + + HRESULT IDXGISwapChain::GetDesc([Out] DXGI_SWAP_CHAIN_DESC* pDesc) + + + + Get the output (the display monitor) that contains the majority of the client area of the target window. + + + If the method succeeds, the output interface will be filled and its reference count incremented. When you are finished with it, be sure to release the interface to avoid a memory leak. The output is also owned by the adapter on which the swap chain's device was created. + + HRESULT IDXGISwapChain::GetContainingOutput([Out] IDXGIOutput** ppOutput) + + + + Get performance statistics about the last render frame. + + + This method is not supported when the swap chain is windowed. + + HRESULT IDXGISwapChain::GetFrameStatistics([Out] DXGI_FRAME_STATISTICS* pStats) + + + + Get the number of times has been called. + + HRESULT IDXGISwapChain::GetLastPresentCount([Out] int* pLastPresentCount) + + + + Gets or sets a value indicating whether the swapchain is in fullscreen. + + + true if this swapchain is in fullscreen; otherwise, false. + + + + + The IDXGIAdapter1 interface represents a display sub-system (including one or more GPU's, DACs and video memory). + + IDXGIAdapter1 + + + + Initializes a new instance of the class. + + The native pointer. + + + + Gets a DXGI 1.1 description of an adapter (or video card). + + + Use the GetDesc1 method to get a DXGI 1.1 description of an adapter. To get a DXGI 1.0 description, use the method. + + A reference to a structure that describes the adapter. This parameter must not be NULL. + Returns S_OK if successful; otherwise returns an error code. Returns if the pDesc parameter is NULL. For a list of error codes, see DXGI_ERROR. + HRESULT IDXGIAdapter1::GetDesc1([Out] DXGI_ADAPTER_DESC1* pDesc) + + + + Gets a DXGI 1.1 description of an adapter (or video card). + + + Use the GetDesc1 method to get a DXGI 1.1 description of an adapter. To get a DXGI 1.0 description, use the method. + + HRESULT IDXGIAdapter1::GetDesc1([Out] DXGI_ADAPTER_DESC1* pDesc) + + + + An IDXGIDevice1 interface implements a derived class for DXGI objects that produce image data. + + IDXGIDevice1 + + + + Initializes a new instance of the class. + + The native pointer. + + + + Sets the number of frames that the system is allowed to queue for rendering. + + + Frame latency is the number of frames that are allowed to be stored in a queue before submission for rendering. Latency is often used to control how the CPU chooses between responding to user input and frames that are in the render queue. It is often beneficial for applications that have no user input (for example, video playback) to queue more than 3 frames of data. + + The maximum number of back buffer frames that a driver can queue. The value defaults to 3, but can range from 1 to 16. A value of 0 will reset latency to the default. For multi-head devices, this value is specified per-head. + Returns S_OK if successful; otherwise, DXGI_ERROR_DEVICE_REMOVED if the device was removed. + HRESULT IDXGIDevice1::SetMaximumFrameLatency([None] int MaxLatency) + + + + Gets the number of frames that the system is allowed to queue for rendering. + + + Frame latency is the number of frames that are allowed to be stored in a queue before submission for rendering. Latency is often used to control how the CPU chooses between responding to user input and frames that are in the render queue. It is often beneficial for applications that have no user input (for example, video playback) to queue more than 3 frames of data. + + This value is set to the number of frames that can be queued for render. This value defaults to 3, but can range from 1 to 16. + Returns S_OK if successful; otherwise, returns one of the following members of the {{D3DERR}} enumerated type: D3DERR_DEVICELOST D3DERR_DEVICEREMOVED D3DERR_DRIVERINTERNALERROR D3DERR_INVALIDCALL D3DERR_OUTOFVIDEOMEMORY + HRESULT IDXGIDevice1::GetMaximumFrameLatency([Out] int* pMaxLatency) + + + + Gets the number of frames that the system is allowed to queue for rendering. + + + Frame latency is the number of frames that are allowed to be stored in a queue before submission for rendering. Latency is often used to control how the CPU chooses between responding to user input and frames that are in the render queue. It is often beneficial for applications that have no user input (for example, video playback) to queue more than 3 frames of data. + + HRESULT IDXGIDevice1::GetMaximumFrameLatency([Out] int* pMaxLatency) + + + + Describes timing and presentation statistics for a frame. + + + The DXGI_FRAME_STATISTICS structure is initialized by the method or by the method. + + DXGI_FRAME_STATISTICS + + + + A value representing the running total count of times that an image has been presented to the monitor since the computer booted. Note that the number of times that an image has been presented to the monitor is not necessarily the same as the number of times that has been called. + + int PresentCount + + + + A value representing the running total count of v-blanks that have happened since the computer booted. + + int PresentRefreshCount + + + + A value representing the running total count of v-blanks that have happened since the computer booted. + + int SyncRefreshCount + + + + A value representing the high-resolution performance counter timer. This value is the same as the value returned by the {{QueryPerformanceCounter}} function. + + __int64 SyncQPCTime + + + + Reserved. Always returns 0. + + __int64 SyncGPUTime + + + + A mapped rectangle used for accessing a surface. + + + The DXGI_MAPPED_RECT structure is initialized by the method. + + DXGI_MAPPED_RECT + + + + A value describing the width of the surface. + + int Pitch + + + + A reference to the image buffer of the surface. + + byte* pBits + + + + Describes an adapter (or video card) by using DXGI 1.0. + + + The DXGI_ADAPTER_DESC structure provides a description of an adapter. This structure is initialized by using the method. + + DXGI_ADAPTER_DESC + + + + A string that contains the adapter description. + + wchar_t Description[128] + + + + The PCI ID of the hardware vendor. + + int VendorId + + + + The PCI ID of the hardware device. + + int DeviceId + + + + The PCI ID of the sub system. + + int SubSysId + + + + The PCI ID of the revision number of the adapter. + + int Revision + + + + The number of bytes of dedicated video memory that are not shared with the CPU. + + SIZE_T DedicatedVideoMemory + + + + The number of bytes of dedicated system memory that are not shared with the GPU. This memory is allocated from available system memory at boot time. + + SIZE_T DedicatedSystemMemory + + + + The number of bytes of shared system memory. This is the maximum value of system memory that may be consumed by the adapter during operation. Any incidental memory consumed by the driver as it manages and uses video memory is additional. + + SIZE_T SharedSystemMemory + + + + A unique value that identifies the adapter. See {{LUID}} for a definition of the structure. LUID is defined in dxgi.h. + + __int64 AdapterLuid + + + + Describes an output or physical connection between the adapter (video card) and a device. + + + The DXGI_OUTPUT_DESC structure is initialized by the method. + + DXGI_OUTPUT_DESC + + + + A string that contains the name of the output device. + + wchar_t DeviceName[32] + + + + A structure containing the bounds of the output in desktop coordinates. + + RECT DesktopCoordinates + + + + A member of the enumerated type describing on how an image is rotated by the output. + + DXGI_MODE_ROTATION Rotation + + + + An {{HMONITOR}} handle that represents the display monitor. For more information, see {{HMONITOR and the Device Context}}. + + void* Monitor + + + + True if the output is attached to the desktop; otherwise, false. + + BOOL AttachedToDesktop + + + + Represents a handle to a shared resource. + + + To create a shared surface, pass a shared-resource handle into the method. + + DXGI_SHARED_RESOURCE + + + + A handle to a shared resource. + + void* Handle + + + + Describes a surface. + + DXGI_SURFACE_DESC + + + + A value describing the surface width. + + int Width + + + + A value describing the surface height. + + int Height + + + + A member of the enumerated type that describes the surface format. + + DXGI_FORMAT Format + + + + A member of the structure that describes multi-sampling parameters for the surface. + + DXGI_SAMPLE_DESC SampleDesc + + + + Describes a swap chain. + + + In full-screen mode, there is a dedicated front buffer; in windowed mode, the desktop is the front buffer. If you create a swap chain with one buffer, specifying DXGI_SWAP_EFFECT_SEQUENTIAL does not cause the contents of the single buffer to be swapped with the front buffer. For performance information about flipping swap-chain buffers in full-screen application, see {{Full-Screen Application Performance Hints}}. + + DXGI_SWAP_CHAIN_DESC + + + + A structure that describes the backbuffer display mode. + + DXGI_MODE_DESC BufferDesc + + + + A structure that describes multi-sampling parameters. + + DXGI_SAMPLE_DESC SampleDesc + + + + A member of the enumerated type that describes the surface usage and CPU access options for the back buffer. The back buffer can be used for shader input or render-target output. + + DXGI_USAGE BufferUsage + + + + A value that describes the number of buffers in the swap chain. When you call to create a full-screen swap chain, you typically include the front buffer in this value. For more information about swap-chain buffers, see Remarks. + + int BufferCount + + + + An {{HWND}} handle to the output window. This member must not be NULL. + + void* OutputWindow + + + + A member of the enumerated type that describes options for handling the contents of the presentation buffer after presenting a surface. + + DXGI_SWAP_EFFECT SwapEffect + + + + A member of the enumerated type that describes options for swap-chain behavior. + + DXGI_SWAP_CHAIN_FLAG Flags + + + + True if the output is in windowed mode; otherwise, false. For more information, see . + + BOOL Windowed + + + + Describes an adapter (or video card) using DXGI 1.1. + + + The DXGI_ADAPTER_DESC1 structure provides a DXGI 1.1 description of an adapter. This structure is initialized by using the method. + + DXGI_ADAPTER_DESC1 + + + + A string that contains the adapter description. + + wchar_t Description[128] + + + + The PCI ID of the hardware vendor. + + int VendorId + + + + The PCI ID of the hardware device. + + int DeviceId + + + + The PCI ID of the sub system. + + int SubSysId + + + + The PCI ID of the revision number of the adapter. + + int Revision + + + + The number of bytes of dedicated video memory that are not shared with the CPU. + + SIZE_T DedicatedVideoMemory + + + + The number of bytes of dedicated system memory that are not shared with the GPU. This memory is allocated from available system memory at boot time. + + SIZE_T DedicatedSystemMemory + + + + The number of bytes of shared system memory. This is the maximum value of system memory that may be consumed by the adapter during operation. Any incidental memory consumed by the driver as it manages and uses video memory is additional. + + SIZE_T SharedSystemMemory + + + + A unique value that identifies the adapter. See {{LUID}} for a definition of the structure. LUID is defined in dxgi.h. + + __int64 AdapterLuid + + + + A value of the enumerated type that describes the adapter type. The DXGI_ADAPTER_FLAG_REMOTE flag is reserved. + + DXGI_ADAPTER_FLAG Flags + + + + Controls the settings of a gamma curve. + + + The DXGI_GAMMA_CONTROL structure is used by the method. + + DXGI_GAMMA_CONTROL + + + + A structure with scalar values that are applied to rgb values before being sent to the gamma look up table. + + DXGI_RGB Scale + + + + A structure with offset values that are applied to the rgb values before being sent to the gamma look up table. + + DXGI_RGB Offset + + + + An array of structures that control the points of a gamma curve. + + DXGI_RGB GammaCurve[1025] + + + + Controls the gamma capabilities of an adapter. + + + To get a list of the capabilities for controlling gamma correction, call . + + DXGI_GAMMA_CONTROL_CAPABILITIES + + + + A value describing the maximum range of the control-point positions. + + float MaxConvertedValue + + + + A value describing the minimum range of the control-point positions. + + float MinConvertedValue + + + + A value describing the number of control points in the array. + + int NumGammaControlPoints + + + + True if scaling and offset operations are supported during gamma correction; otherwise, false. + + BOOL ScaleAndOffsetSupported + + + + An array of values describing control points; the maximum length of control points is 1025. + + float ControlPointPositions[1025] + + + + Represents a rational number. + + + The DXGI_RATIONAL structure operates under the following rules: 0/0 is legal and will be interpreted as 0/1. 0/anything is interpreted as zero. If you are representing a whole number, the denominator should be 1. + + DXGI_RATIONAL + + + + An unsigned integer value representing the top of the rational number. + + int Numerator + + + + An unsigned integer value representing the bottom of the rational number. + + int Denominator + + + + Initializes a new instance of the structure. + + The numerator of the rational pair. + The denominator of the rational pair. + + + + Describes a display mode. + + DXGI_MODE_DESC + + + + A value describing the resolution width. + + int Width + + + + A value describing the resolution height. + + int Height + + + + A structure describing the refresh rate in hertz + + DXGI_RATIONAL RefreshRate + + + + A structure describing the display format. + + DXGI_FORMAT Format + + + + A member of the enumerated type describing the scanline drawing mode. + + DXGI_MODE_SCANLINE_ORDER ScanlineOrdering + + + + A member of the enumerated type describing the scaling mode. + + DXGI_MODE_SCALING Scaling + + + + Initializes a new instance of the structure. + + The width. + The height. + The refresh rate. + The format. + + + + Describes multi-sampling parameters for a resource. + + + The default sampler mode, with no anti-aliasing, has a count of 1 and a quality level of 0. If multi-sample antialiasing is being used, all bound render targets and depth buffers must have the same sample counts and quality levels. Differences between Direct3D 10.0 and Direct3D 10.1 and between Direct3D 10.0 and Direct3D 11: Direct3D 10.1 has defined two standard quality levels: D3D10_STANDARD_MULTISAMPLE_PATTERN and D3D10_CENTER_MULTISAMPLE_PATTERN in the D3D10_STANDARD_MULTISAMPLE_QUALITY_LEVELS enumeration in D3D10_1.h. Direct3D 11 has defined two standard quality levels: D3D11_STANDARD_MULTISAMPLE_PATTERN and D3D11_CENTER_MULTISAMPLE_PATTERN in the enumeration in D3D11.h. ? + + DXGI_SAMPLE_DESC + + + + The number of multisamples per pixel. + + int Count + + + + The image quality level. The higher the quality, the lower the performance. The valid range is between zero and one less than the level returned by for Direct3D 10 or for Direct3D 11. For Direct3D 10.1 and Direct3D 11, you can use two special quality level values. For more information about these quality level values, see Remarks. + + int Quality + + + + Initializes a new instance of the structure. + + The sample count. + The sample quality. + + + diff --git a/Libs/SharpDX.Direct2D1.dll b/Libs/SharpDX.Direct2D1.dll new file mode 100644 index 0000000000000000000000000000000000000000..c8bcb15faf05eb536de4daf4d33681c10ce2f957 GIT binary patch literal 134144 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

Q&SdN2Qqz*a@QJn`50D+9Z1>c8__ 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 UoC2)%y7PTZitRT)|L-X9KhF2yKmY&$ literal 0 HcmV?d00001 diff --git a/Libs/SharpDX.Direct2D1.xml b/Libs/SharpDX.Direct2D1.xml new file mode 100644 index 0000000..e8859c9 --- /dev/null +++ b/Libs/SharpDX.Direct2D1.xml @@ -0,0 +1,11469 @@ + + + + SharpDX.Direct2D1 + + + +

+ Encapsulates a 32-bit device independent bitmap and device context, which can be used for rendering glyphs. + + IDWriteBitmapRenderTarget + + + + Draws a run of glyphs to a bitmap target at the specified position. + + + You can use the IDWriteBitmapRenderTarget::DrawGlyphRun to render to a bitmap from a custom text renderer that you implement. The custom text renderer should call this method from within the callback method as shown in the following code. + STDMETHODIMP GdiTextRenderer::DrawGlyphRun( __maybenull void* clientDrawingContext, FLOAT baselineOriginX, FLOAT baselineOriginY, DWRITE_MEASURING_MODE measuringMode, __in DWRITE_GLYPH_RUN const* glyphRun, __in DWRITE_GLYPH_RUN_DESCRIPTION const* glyphRunDescription, IUnknown* clientDrawingEffect ) + { HRESULT hr = S_OK; // Pass on the drawing call to the render target to do the real work. RECT dirtyRect = {0}; hr = pRenderTarget_->DrawGlyphRun( baselineOriginX, baselineOriginY, measuringMode, glyphRun, pRenderingParams_, RGB(0,200,255), &dirtyRect ); return hr; + } + + The baselineOriginX, baslineOriginY, measuringMethod, and glyphRun parameters are provided (as arguments) when the callback method is invoked. The renderingParams, textColor and blackBoxRect are not. Default rendering params can be retrieved by using the method. + + The horizontal position of the baseline origin, in DIPs, relative to the upper-left corner of the DIB. + The vertical position of the baseline origin, in DIPs, relative to the upper-left corner of the DIB. + The measuring method for glyphs in the run, used with the other properties to determine the rendering mode. + The structure containing the properties of the glyph run. + The object that controls rendering behavior. + The foreground color of the text. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteBitmapRenderTarget::DrawGlyphRun([None] float baselineOriginX,[None] float baselineOriginY,[None] DWRITE_MEASURING_MODE measuringMode,[In] const DWRITE_GLYPH_RUN* glyphRun,[None] IDWriteRenderingParams* renderingParams,[None] COLORREF textColor,[Out, Optional] RECT* blackBoxRect) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Draws a run of glyphs to a bitmap target at the specified position. + + + You can use the IDWriteBitmapRenderTarget::DrawGlyphRun to render to a bitmap from a custom text renderer that you implement. The custom text renderer should call this method from within the callback method as shown in the following code. + STDMETHODIMP GdiTextRenderer::DrawGlyphRun( __maybenull void* clientDrawingContext, FLOAT baselineOriginX, FLOAT baselineOriginY, DWRITE_MEASURING_MODE measuringMode, __in DWRITE_GLYPH_RUN const* glyphRun, __in DWRITE_GLYPH_RUN_DESCRIPTION const* glyphRunDescription, IUnknown* clientDrawingEffect ) + { HRESULT hr = S_OK; // Pass on the drawing call to the render target to do the real work. RECT dirtyRect = {0}; hr = pRenderTarget_->DrawGlyphRun( baselineOriginX, baselineOriginY, measuringMode, glyphRun, pRenderingParams_, RGB(0,200,255), &dirtyRect ); return hr; + } + + The baselineOriginX, baslineOriginY, measuringMethod, and glyphRun parameters are provided (as arguments) when the callback method is invoked. The renderingParams, textColor and blackBoxRect are not. Default rendering params can be retrieved by using the method. + + The horizontal position of the baseline origin, in DIPs, relative to the upper-left corner of the DIB. + The vertical position of the baseline origin, in DIPs, relative to the upper-left corner of the DIB. + The measuring method for glyphs in the run, used with the other properties to determine the rendering mode. + The structure containing the properties of the glyph run. + The object that controls rendering behavior. + The foreground color of the text. + The optional rectangle that receives the bounding box (in pixels not DIPs) of all the pixels affected by drawing the glyph run. The black box rectangle may extend beyond the dimensions of the bitmap. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteBitmapRenderTarget::DrawGlyphRun([None] float baselineOriginX,[None] float baselineOriginY,[None] DWRITE_MEASURING_MODE measuringMode,[In] const DWRITE_GLYPH_RUN* glyphRun,[None] IDWriteRenderingParams* renderingParams,[None] COLORREF textColor,[Out, Optional] RECT* blackBoxRect) + + + + Gets a handle to the memory device context. + + + An application can use the device context to draw using GDI functions. An application can obtain the bitmap handle (HBITMAP) by calling {{GetCurrentObject}}. An application that wants information about the underlying bitmap, including a reference to the pixel data, can call {{GetObject}} to fill in a {{DIBSECTION}} structure. The bitmap is always a 32-bit top-down DIB. Note that this method takes no parameters and returns an HDC variable, not an HRESULT. + memoryHdc = g_pBitmapRenderTarget->GetMemoryDC(); + + The HDC returned here is still owned by the bitmap render targer object and should not be released or deleted by the client. + + Returns a device context handle to the memory device context. + void* IDWriteBitmapRenderTarget::GetMemoryDC() + + + + Gets the number of bitmap pixels per DIP. + + + A DIP (device-independent pixel) is 1/96 inch. Therefore, this value is the number if pixels per inch divided by 96. + + The number of bitmap pixels per DIP. + float IDWriteBitmapRenderTarget::GetPixelsPerDip() + + + + Sets the number of bitmap pixels per DIP (device-independent pixel). A DIP is 1/96 inch, so this value is the number if pixels per inch divided by 96. + + A value that specifies the number of pixels per DIP. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteBitmapRenderTarget::SetPixelsPerDip([None] float pixelsPerDip) + + + + Gets the transform that maps abstract coordinates to DIPs. By default this is the identity transform. Note that this is unrelated to the world transform of the underlying device context. + + When this method returns, contains a transform matrix. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteBitmapRenderTarget::GetCurrentTransform([Out] DWRITE_MATRIX* transform) + + + + Sets the transform that maps abstract coordinate to DIPs (device-independent pixel). This does not affect the world transform of the underlying device context. + + Specifies the new transform. This parameter can be NULL, in which case the identity transform is implied. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteBitmapRenderTarget::SetCurrentTransform([In, Optional] const DWRITE_MATRIX* transform) + + + + Gets the dimensions of the target bitmap. + + Returns the width and height of the bitmap in pixels. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteBitmapRenderTarget::GetSize([Out] SIZE* size) + + + + Resizes the bitmap. + + The new bitmap width, in pixels. + The new bitmap height, in pixels. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteBitmapRenderTarget::Resize([None] int width,[None] int height) + + + + Gets a handle to the memory device context. + + + An application can use the device context to draw using GDI functions. An application can obtain the bitmap handle (HBITMAP) by calling {{GetCurrentObject}}. An application that wants information about the underlying bitmap, including a reference to the pixel data, can call {{GetObject}} to fill in a {{DIBSECTION}} structure. The bitmap is always a 32-bit top-down DIB. Note that this method takes no parameters and returns an HDC variable, not an HRESULT. + memoryHdc = g_pBitmapRenderTarget->GetMemoryDC(); + + The HDC returned here is still owned by the bitmap render targer object and should not be released or deleted by the client. + + void* IDWriteBitmapRenderTarget::GetMemoryDC() + + + + Gets the number of bitmap pixels per DIP. + + + A DIP (device-independent pixel) is 1/96 inch. Therefore, this value is the number if pixels per inch divided by 96. + + float IDWriteBitmapRenderTarget::GetPixelsPerDip() + + + + Gets the transform that maps abstract coordinates to DIPs. By default this is the identity transform. Note that this is unrelated to the world transform of the underlying device context. + + HRESULT IDWriteBitmapRenderTarget::GetCurrentTransform([Out] DWRITE_MATRIX* transform) + + + + Gets the dimensions of the target bitmap. + + HRESULT IDWriteBitmapRenderTarget::GetSize([Out] SIZE* size) + + + + An inline object for trimming, using an ellipsis as the omission sign. + + + + + Wraps an application-defined inline graphic, allowing DWrite to query metrics as if the graphic were a glyph inline with the text. + + IDWriteInlineObject + + + + Wraps an application-defined inline graphic, allowing DWrite to query metrics as if the graphic were a glyph inline with the text. + + IDWriteInlineObject + + + + The application implemented rendering callback () can use this to draw the inline object without needing to cast or query the object type. The text layout does not call this method directly. + + The drawing context passed to . This parameter may be NULL. + The same renderer passed to as the object's containing parent. This is useful if the inline object is recursive such as a nested layout. + The x-coordinate at the upper-left corner of the inline object. + The y-coordinate at the upper-left corner of the inline object. + A Boolean flag that indicates whether the object's baseline runs alongside the baseline axis of the line. + A Boolean flag that indicates whether the object is in a right-to-left context and should be drawn flipped. + The drawing effect set in . Usually this effect is a foreground brush that is used in glyph drawing. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteInlineObject::Draw([None] void* clientDrawingContext,[None] IDWriteTextRenderer* renderer,[None] float originX,[None] float originY,[None] BOOL isSideways,[None] BOOL isRightToLeft,[None] IUnknown* clientDrawingEffect) + + + + Layout uses this to determine the line-breaking behavior of the inline object among the text. + + When this method returns, contains a value which indicates the line-breaking condition between the object and the content immediately preceding it. + When this method returns, contains a value which indicates the line-breaking condition between the object and the content immediately following it. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteInlineObject::GetBreakConditions([Out] DWRITE_BREAK_CONDITION* breakConditionBefore,[Out] DWRITE_BREAK_CONDITION* breakConditionAfter) + + + + calls this callback function to get the measurement of the inline object. + + a structure describing the geometric measurement of anapplication-defined inline object. These metrics are in relation to the baseline of the adjacent text. + HRESULT IDWriteInlineObject::GetMetrics([Out] DWRITE_INLINE_OBJECT_METRICS* metrics) + + + + TextLayout calls this callback function to get the visible extents (in DIPs) of the inline object. In the case of a simple bitmap, with no padding and no overhang, all the overhangs will simply be zeroes. + + Overshoot of visible extents (in DIPs) outside the object. + HRESULT IDWriteInlineObject::GetOverhangMetrics([Out] DWRITE_OVERHANG_METRICS* overhangs) + + + + The application implemented rendering callback () can use this to draw the inline object without needing to cast or query the object type. The text layout does not call this method directly. + + The drawing context passed to . This parameter may be NULL. + The same renderer passed to as the object's containing parent. This is useful if the inline object is recursive such as a nested layout. + The x-coordinate at the upper-left corner of the inline object. + The y-coordinate at the upper-left corner of the inline object. + A Boolean flag that indicates whether the object's baseline runs alongside the baseline axis of the line. + A Boolean flag that indicates whether the object is in a right-to-left context and should be drawn flipped. + The drawing effect set in . Usually this effect is a foreground brush that is used in glyph drawing. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteInlineObject::Draw([None] void* clientDrawingContext,[None] IDWriteTextRenderer* renderer,[None] float originX,[None] float originY,[None] BOOL isSideways,[None] BOOL isRightToLeft,[None] IUnknown* clientDrawingEffect) + + + + Layout uses this to determine the line-breaking behavior of the inline object among the text. + + When this method returns, contains a value which indicates the line-breaking condition between the object and the content immediately preceding it. + When this method returns, contains a value which indicates the line-breaking condition between the object and the content immediately following it. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteInlineObject::GetBreakConditions([Out] DWRITE_BREAK_CONDITION* breakConditionBefore,[Out] DWRITE_BREAK_CONDITION* breakConditionAfter) + + + + Initializes a new instance of the class. + + The native pointer. + + + + The application implemented rendering callback () can use this to draw the inline object without needing to cast or query the object type. The text layout does not call this method directly. + + The drawing context passed to . This parameter may be NULL. + The same renderer passed to as the object's containing parent. This is useful if the inline object is recursive such as a nested layout. + The x-coordinate at the upper-left corner of the inline object. + The y-coordinate at the upper-left corner of the inline object. + A Boolean flag that indicates whether the object's baseline runs alongside the baseline axis of the line. + A Boolean flag that indicates whether the object is in a right-to-left context and should be drawn flipped. + The drawing effect set in . Usually this effect is a foreground brush that is used in glyph drawing. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteInlineObject::Draw([None] void* clientDrawingContext,[None] IDWriteTextRenderer* renderer,[None] float originX,[None] float originY,[None] BOOL isSideways,[None] BOOL isRightToLeft,[None] void* clientDrawingEffect) + + + + calls this callback function to get the measurement of the inline object. + + When this method returns, contains a structure describing the geometric measurement of anapplication-defined inline object. These metrics are in relation to the baseline of the adjacent text. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteInlineObject::GetMetrics([Out] DWRITE_INLINE_OBJECT_METRICS* metrics) + + + + TextLayout calls this callback function to get the visible extents (in DIPs) of the inline object. In the case of a simple bitmap, with no padding and no overhang, all the overhangs will simply be zeroes. + + Overshoot of visible extents (in DIPs) outside the object. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteInlineObject::GetOverhangMetrics([Out] DWRITE_OVERHANG_METRICS* overhangs) + + + + Layout uses this to determine the line-breaking behavior of the inline object among the text. + + When this method returns, contains a value which indicates the line-breaking condition between the object and the content immediately preceding it. + When this method returns, contains a value which indicates the line-breaking condition between the object and the content immediately following it. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteInlineObject::GetBreakConditions([Out] DWRITE_BREAK_CONDITION* breakConditionBefore,[Out] DWRITE_BREAK_CONDITION* breakConditionAfter) + + + + calls this callback function to get the measurement of the inline object. + + a structure describing the geometric measurement of anapplication-defined inline object. These metrics are in relation to the baseline of the adjacent text. + HRESULT IDWriteInlineObject::GetMetrics([Out] DWRITE_INLINE_OBJECT_METRICS* metrics) + + + + TextLayout calls this callback function to get the visible extents (in DIPs) of the inline object. In the case of a simple bitmap, with no padding and no overhang, all the overhangs will simply be zeroes. + + Overshoot of visible extents (in DIPs) outside the object. + HRESULT IDWriteInlineObject::GetOverhangMetrics([Out] DWRITE_OVERHANG_METRICS* overhangs) + + + + Initializes a new instance of the class. + + The native PTR. + + + + Creates an inline object for trimming, using an ellipsis as the omission sign. + + + The ellipsis will be created using the current settings of the format, including base font, style, and any effects. Alternate omission signs can be created by the application by implementing . + + a + A text format object, created with {{CreateTextFormat}}, used for text layout. + HRESULT IDWriteFactory::CreateEllipsisTrimmingSign([None] IDWriteTextFormat* textFormat,[Out] IDWriteInlineObject** trimmingSign) + + + + Used to create all subsequent DirectWrite objects. This interface is the root factory interface for all DirectWrite objects. + + IDWriteFactory + + + + Default Constructor for a . + + + + + Default Constructor for a . + + + + + Registers a custom font collection loader with the factory object. + + + This function registers a font collection loader with DirectWrite. The font collection loader interface, which should be implemented by a singleton object, handles enumerating font files in a font collection given a particular type of key. A given instance can only be registered once. Succeeding attempts will return an error, indicating that it has already been registered. Note that font file loader implementations must not register themselves with DirectWrite inside their constructors, and must not unregister themselves inside their destructors, because registration and unregistraton operations increment and decrement the object reference count respectively. Instead, registration and unregistration with DirectWrite of font file loaders should be performed outside of the font file loader implementation. + + Reference to a object to be registered. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::RegisterFontCollectionLoader([None] IDWriteFontCollectionLoader* fontCollectionLoader) + + + + Unregisters a custom font collection loader that was previously registered using {{RegisterFontCollectionLoader}}. + + Pointer to a object to be unregistered. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::UnregisterFontCollectionLoader([None] IDWriteFontCollectionLoader* fontCollectionLoader) + + + + Registers a font file loader with DirectWrite. + + + This function registers a font file loader with DirectWrite. The font file loader interface, which should be implemented by a singleton object, handles loading font file resources of a particular type from a key. A given instance can only be registered once. Succeeding attempts will return an error, indicating that it has already been registered. Note that font file loader implementations must not register themselves with DirectWrite inside their constructors, and must not unregister themselves inside their destructors, because registration and unregistraton operations increment and decrement the object reference count respectively. Instead, registration and unregistration with DirectWrite of font file loaders should be performed outside of the font file loader implementation. + + Pointer to a object for a particular file resource type. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::RegisterFontFileLoader([None] IDWriteFontFileLoader* fontFileLoader) + + + + Unregisters a font file loader that was previously registered with the DirectWrite font system using {{RegisterFontFileLoader}}. + + + This function unregisters font file loader callbacks with the DirectWrite font system. You should implement the font file loader interface by a singleton object. Note that font file loader implementations must not register themselves with DirectWrite inside their constructors and must not unregister themselves in their destructors, because registration and unregistraton operations increment and decrement the object reference count respectively. Instead, registration and unregistration of font file loaders with DirectWrite should be performed outside of the font file loader implementation. + + Pointer to the file loader that was previously registered with the DirectWrite font system using {{RegisterFontFileLoader}}. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::UnregisterFontFileLoader([None] IDWriteFontFileLoader* fontFileLoader) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Gets an object which represents the set of installed fonts. + + If this parameter is nonzero, the function performs an immediate check for changes to the set of installed fonts. If this parameter is FALSE, the function will still detect changes if the font cache service is running, but there may be some latency. For example, an application might specify TRUE if it has itself just installed a font and wants to be sure the font collection contains that font. + When this method returns, contains the address of a reference to the system font collection object, or NULL in case of failure. + HRESULT IDWriteFactory::GetSystemFontCollection([Out] IDWriteFontCollection** fontCollection,[None] BOOL checkForUpdates) + + + + Creates a font collection using a custom font collection loader. + + An application-defined font collection loader, which must have been previously registered using {{RegisterFontCollectionLoader}}. + The key used by the loader to identify a collection of font files. The buffer allocated for this key should at least be the size of collectionKeySize. + The size, in bytes, of the collection key. + Contains an address of a reference to the system font collection object if the method succeeds, or NULL in case of failure. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::CreateCustomFontCollection([None] IDWriteFontCollectionLoader* collectionLoader,[In, Buffer] const void* collectionKey,[None] int collectionKeySize,[Out] IDWriteFontCollection** fontCollection) + + + + Registers a custom font collection loader with the factory object. + + + This function registers a font collection loader with DirectWrite. The font collection loader interface, which should be implemented by a singleton object, handles enumerating font files in a font collection given a particular type of key. A given instance can only be registered once. Succeeding attempts will return an error, indicating that it has already been registered. Note that font file loader implementations must not register themselves with DirectWrite inside their constructors, and must not unregister themselves inside their destructors, because registration and unregistraton operations increment and decrement the object reference count respectively. Instead, registration and unregistration with DirectWrite of font file loaders should be performed outside of the font file loader implementation. + + Pointer to a object to be registered. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::RegisterFontCollectionLoader([None] IDWriteFontCollectionLoader* fontCollectionLoader) + + + + Unregisters a custom font collection loader that was previously registered using {{RegisterFontCollectionLoader}}. + + Pointer to a object to be unregistered. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::UnregisterFontCollectionLoader([None] IDWriteFontCollectionLoader* fontCollectionLoader) + + + + Creates a font file reference object from a local font file. + + An array of characters that contains the absolute file path for the font file. Subsequent operations on the constructed object may fail if the user provided filePath doesn't correspond to a valid file on the disk. + The last modified time of the input file path. If the parameter is omitted, the function will access the font file to obtain its last write time. You should specify this value to avoid extra disk access. Subsequent operations on the constructed object may fail if the user provided lastWriteTime doesn't match the file on the disk. + When this method returns, contains an address of a reference to the newly created font file reference object, or NULL in case of failure. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::CreateFontFileReference([In] const wchar_t* filePath,[In, Optional] const __int64* lastWriteTime,[Out] IDWriteFontFile** fontFile) + + + + Creates a reference to an application-specific font file resource. + + + This function is provided for cases when an application or a document needs to use a private font without having to install it on the system. fontFileReferenceKey has to be unique only in the scope of the fontFileLoader used in this call. + + A font file reference key that uniquely identifies the font file resource during the lifetime of fontFileLoader. + The size of the font file reference key in bytes. + The font file loader that will be used by the font system to load data from the file identified by fontFileReferenceKey. + Contains an address of a reference to the newly created font file object when this method succeeds, or NULL in case of failure. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::CreateCustomFontFileReference([In, Buffer] const void* fontFileReferenceKey,[None] int fontFileReferenceKeySize,[None] IDWriteFontFileLoader* fontFileLoader,[Out] IDWriteFontFile** fontFile) + + + + Creates an object that represents a font face. + + A value that indicates the type of file format of the font face. + The number of font files, in element count, required to represent the font face. + A font file object representing the font face. Because maintains its own references to the input font file objects, you may release them after this call. + The zero-based index of a font face, in cases when the font files contain a collection of font faces. If the font files contain a single face, this value should be zero. + A value that indicates which, if any, font face simulation flags for algorithmic means of making text bold or italic are applied to the current font face. + When this method returns, contains an address of a reference to the newly created font face object, or NULL in case of failure. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::CreateFontFace([None] DWRITE_FONT_FACE_TYPE fontFaceType,[None] int numberOfFiles,[In, Buffer] const IDWriteFontFile** fontFiles,[None] int faceIndex,[None] DWRITE_FONT_SIMULATIONS fontFaceSimulationFlags,[Out] IDWriteFontFace** fontFace) + + + + Creates a rendering parameters object with default settings for the primary monitor. Different monitors may have different rendering parameters, for more information see the {{How to Add Support for Multiple Monitors}} topic. + + When this method returns, contains an address of a reference to the newly created rendering parameters object. + Standard HRESULT error code. + HRESULT IDWriteFactory::CreateRenderingParams([Out] IDWriteRenderingParams** renderingParams) + + + + Creates a rendering parameters object with default settings for the specified monitor. In most cases, this is the preferred way to create a rendering parameters object. + + A handle for the specified monitor. + When this method returns, contains an address of a reference to the rendering parameters object created by this method. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::CreateMonitorRenderingParams([None] void* monitor,[Out] IDWriteRenderingParams** renderingParams) + + + + Creates a rendering parameters object with the specified properties. + + The gamma level to be set for the new rendering parameters object. + The enhanced contrast level to be set for the new rendering parameters object. + The ClearType level to be set for the new rendering parameters object. + Represents the internal structure of a device pixel (that is, the physical arrangement of red, green, and blue color components) that is assumed for purposes of rendering text. + A value that represents the method (for example, ClearType natural quality) for rendering glyphs. + When this method returns, contains an address of a reference to the newly created rendering parameters object. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::CreateCustomRenderingParams([None] float gamma,[None] float enhancedContrast,[None] float clearTypeLevel,[None] DWRITE_PIXEL_GEOMETRY pixelGeometry,[None] DWRITE_RENDERING_MODE renderingMode,[Out] IDWriteRenderingParams** renderingParams) + + + + Registers a font file loader with DirectWrite. + + + This function registers a font file loader with DirectWrite. The font file loader interface, which should be implemented by a singleton object, handles loading font file resources of a particular type from a key. A given instance can only be registered once. Succeeding attempts will return an error, indicating that it has already been registered. Note that font file loader implementations must not register themselves with DirectWrite inside their constructors, and must not unregister themselves inside their destructors, because registration and unregistraton operations increment and decrement the object reference count respectively. Instead, registration and unregistration with DirectWrite of font file loaders should be performed outside of the font file loader implementation. + + Pointer to a object for a particular file resource type. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::RegisterFontFileLoader([None] IDWriteFontFileLoader* fontFileLoader) + + + + Unregisters a font file loader that was previously registered with the DirectWrite font system using {{RegisterFontFileLoader}}. + + + This function unregisters font file loader callbacks with the DirectWrite font system. You should implement the font file loader interface by a singleton object. Note that font file loader implementations must not register themselves with DirectWrite inside their constructors and must not unregister themselves in their destructors, because registration and unregistraton operations increment and decrement the object reference count respectively. Instead, registration and unregistration of font file loaders with DirectWrite should be performed outside of the font file loader implementation. + + Pointer to the file loader that was previously registered with the DirectWrite font system using {{RegisterFontFileLoader}}. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::UnregisterFontFileLoader([None] IDWriteFontFileLoader* fontFileLoader) + + + + Creates a text format object used for text layout. + + An array of characters that contains the name of the font family + A reference to a font collection object. When this is NULL, indicates the system font collection. + A value that indicates the font weight for the text object created by this method. + A value that indicates the font style for the text object created by this method. + A value that indicates the font stretch for the text object created by this method. + The logical size of the font in DIP ("device-independent pixel") units. A DIP equals 1/96 inch. + An array of characters that contains the locale name. + When this method returns, contains an address of a reference to a newly created text format object, or NULL in case of failure. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::CreateTextFormat([In] const wchar_t* fontFamilyName,[None] IDWriteFontCollection* fontCollection,[None] DWRITE_FONT_WEIGHT fontWeight,[None] DWRITE_FONT_STYLE fontStyle,[None] DWRITE_FONT_STRETCH fontStretch,[None] float fontSize,[In] const wchar_t* localeName,[Out] IDWriteTextFormat** textFormat) + + + + Creates a typography object for use in a text layout. + + When this method returns, contains the address of a reference to a newly created typography object, or NULL in case of failure. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::CreateTypography([Out] IDWriteTypography** typography) + + + + Creates an object that is used for interoperability with GDI. + + When this method returns, contains an address of a reference to a GDI interop object if successful, or NULL in case of failure. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::GetGdiInterop([Out] IDWriteGdiInterop** gdiInterop) + + + + Takes a string, text format, and associated constraints, and produces an object that represents the fully analyzed and formatted result. + + An array of characters that contains the string to create a new object from. This array must be of length stringLength and can contain embedded NULL characters. + The number of characters in the string. + A reference to an object that indicates the format to apply to the string. + The width of the layout box. + The height of the layout box. + When this method returns, contains an address of a reference to the resultant text layout object. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::CreateTextLayout([In, Buffer] const wchar_t* string,[None] int stringLength,[None] IDWriteTextFormat* textFormat,[None] float maxWidth,[None] float maxHeight,[Out] IDWriteTextLayout** textLayout) + + + + Takes a string, format, and associated constraints, and produces an object representing the result, formatted for a particular display resolution and measuring mode. + + + The resulting text layout should only be used for the intended resolution, and for cases where text scalability is desired {{CreateTextLayout}} should be used instead. + + An array of characters that contains the string to create a new object from. This array must be of length stringLength and can contain embedded NULL characters. + The length of the string, in character count. + The text formatting object to apply to the string. + The width of the layout box. + The height of the layout box. + The number of physical pixels per DIP (device independent pixel). For example, if rendering onto a 96 DPI device pixelsPerDip is 1. If rendering onto a 120 DPI device pixelsPerDip is 1.25 (120/96). + An optional transform applied to the glyphs and their positions. This transform is applied after the scaling specifies the font size and pixels per DIP. + Instructs the text layout to use the same metrics as GDI bi-level text when set to FALSE. When set to TRUE, instructs the text layout to use the same metrics as text measured by GDI using a font created with CLEARTYPE_NATURAL_QUALITY. + When this method returns, contains an address to the reference of the resultant text layout object. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::CreateGdiCompatibleTextLayout([In, Buffer] const wchar_t* string,[None] int stringLength,[None] IDWriteTextFormat* textFormat,[None] float layoutWidth,[None] float layoutHeight,[None] float pixelsPerDip,[In, Optional] const DWRITE_MATRIX* transform,[None] BOOL useGdiNatural,[Out] IDWriteTextLayout** textLayout) + + + + Creates an inline object for trimming, using an ellipsis as the omission sign. + + + The ellipsis will be created using the current settings of the format, including base font, style, and any effects. Alternate omission signs can be created by the application by implementing . + + A text format object, created with {{CreateTextFormat}}, used for text layout. + When this method returns, contains an address of a reference to the omission (that is, ellipsis trimming) sign created by this method. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::CreateEllipsisTrimmingSign([None] IDWriteTextFormat* textFormat,[Out] IDWriteInlineObject** trimmingSign) + + + + Returns an interface for performing text analysis. + + When this method returns, contains an address of a reference to the newly created text analyzer object. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::CreateTextAnalyzer([Out] IDWriteTextAnalyzer** textAnalyzer) + + + + Creates a number substitution object using a locale name, substitution method, and an indicator whether to ignore user overrides (use NLS defaults for the given culture instead). + + A value that specifies how to apply number substitution on digits and related punctuation. + The name of the locale to be used in the numberSubstitution object. + A Boolean flag that indicates whether to ignore user overrides. + When this method returns, contains an address to a reference to the number substitution object created by this method. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::CreateNumberSubstitution([In] DWRITE_NUMBER_SUBSTITUTION_METHOD substitutionMethod,[In] const wchar_t* localeName,[In] BOOL ignoreUserOverride,[Out] IDWriteNumberSubstitution** numberSubstitution) + + + + Creates a glyph run analysis object, which encapsulates information used to render a glyph run. + + + The glyph run analysis object contains the results of analyzing the glyph run, including the positions of all the glyphs and references to all of the rasterized glyphs in the font cache. + + A structure that contains the properties of the glyph run (font face, advances, and so on). + Number of physical pixels per DIP (device independent pixel). For example, if rendering onto a 96 DPI bitmap then pixelsPerDip is 1. If rendering onto a 120 DPI bitmap then pixelsPerDip is 1.25. + Optional transform applied to the glyphs and their positions. This transform is applied after the scaling specified the emSize and pixelsPerDip. + A value that specifies the rendering mode, which must be one of the raster rendering modes (that is, not default and not outline). + Specifies the measuring mode to use with glyphs. + The horizontal position (X-coordinate) of the baseline origin, in DIPs. + Vertical position (Y-coordinate) of the baseline origin, in DIPs. + When this method returns, contains an address of a reference to the newly created glyph run analysis object. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFactory::CreateGlyphRunAnalysis([In] const DWRITE_GLYPH_RUN* glyphRun,[None] float pixelsPerDip,[In, Optional] const DWRITE_MATRIX* transform,[None] DWRITE_RENDERING_MODE renderingMode,[None] DWRITE_MEASURING_MODE measuringMode,[None] float baselineOriginX,[None] float baselineOriginY,[Out] IDWriteGlyphRunAnalysis** glyphRunAnalysis) + + + + Creates an object that is used for interoperability with GDI. + + HRESULT IDWriteFactory::GetGdiInterop([Out] IDWriteGdiInterop** gdiInterop) + + + + Represents a physical font in a font collection. This interface is used to create font faces from physical fonts, or to retrieve information such as font face metrics or face names from existing font faces. + + IDWriteFont + + + + Gets a localized strings collection containing the specified informational strings, indexed by locale name. + + + If the font does not contain the string specified by informationalStringID, the return value is S_OK but informationalStrings receives a NULL reference and exists receives the value FALSE. + + A value that identifies the informational string to get. For example, specifies a string that contains a description of the font. + When this method returns, contains an address of a reference to the newly created localized strings object. + TRUE if the font contains the specified string ID; otherwise, FALSE. + HRESULT IDWriteFont::GetInformationalStrings([None] DWRITE_INFORMATIONAL_STRING_ID informationalStringID,[Out] IDWriteLocalizedStrings** informationalStrings,[Out] BOOL* exists) + + + + Determines whether the font supports a specified character. + + A Unicode (UCS-4) character value for the method to inspect. + TRUE if the font supports the specified character; otherwise, FALSE. + HRESULT IDWriteFont::HasCharacter([None] int unicodeValue,[Out] BOOL* exists) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Gets the font family to which the specified font belongs. + + When this method returns, contains an address of a reference to the font family object to which the specified font belongs. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFont::GetFontFamily([Out] IDWriteFontFamily** fontFamily) + + + + Gets the weight, or stroke thickness, of the specified font. + + A value that indicates the weight for the specified font. + DWRITE_FONT_WEIGHT IDWriteFont::GetWeight() + + + + Gets the stretch, or width, of the specified font. + + A value that indicates the type of stretch, or width, applied to the specified font. + DWRITE_FONT_STRETCH IDWriteFont::GetStretch() + + + + Gets the style, or slope, of the specified font. + + A value that indicates the type of style, or slope, of the specified font. + DWRITE_FONT_STYLE IDWriteFont::GetStyle() + + + + Determines whether the font is a symbol font. + + TRUE if the font is a symbol font; otherwise, FALSE. + BOOL IDWriteFont::IsSymbolFont() + + + + Gets a localized strings collection containing the face names for the font (such as Regular or Bold), indexed by locale name. + + When this method returns, contains an address to a reference to the newly created localized strings object. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFont::GetFaceNames([Out] IDWriteLocalizedStrings** names) + + + + Gets a localized strings collection containing the specified informational strings, indexed by locale name. + + + If the font does not contain the string specified by informationalStringID, the return value is S_OK but informationalStrings receives a NULL reference and exists receives the value FALSE. + + A value that identifies the informational string to get. For example, specifies a string that contains a description of the font. + When this method returns, contains an address of a reference to the newly created localized strings object. + When this method returns, TRUE if the font contains the specified string ID; otherwise, FALSE. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFont::GetInformationalStrings([None] DWRITE_INFORMATIONAL_STRING_ID informationalStringID,[Out] IDWriteLocalizedStrings** informationalStrings,[Out] BOOL* exists) + + + + Gets a value that indicates what simulations are applied to the specified font. + + A value that indicates one or more of the types of simulations (none, bold, or oblique) applied to the specified font. + DWRITE_FONT_SIMULATIONS IDWriteFont::GetSimulations() + + + + Obtains design units and common metrics for the font face. These metrics are applicable to all the glyphs within a font face and are used by applications for layout calculations. + + When this method returns, contains a structure that has font metrics for the current font face. The metrics returned by this function are in font design units. + void IDWriteFont::GetMetrics([Out] DWRITE_FONT_METRICS* fontMetrics) + + + + Determines whether the font supports a specified character. + + A Unicode (UCS-4) character value for the method to inspect. + When this method returns, TRUE if the font supports the specified character; otherwise, FALSE. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFont::HasCharacter([None] int unicodeValue,[Out] BOOL* exists) + + + + Creates a font face object for the font. + + When this method returns, contains an address of a reference to the newly created font face object. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFont::CreateFontFace([Out] IDWriteFontFace** fontFace) + + + + Gets the font family to which the specified font belongs. + + HRESULT IDWriteFont::GetFontFamily([Out] IDWriteFontFamily** fontFamily) + + + + Gets the weight, or stroke thickness, of the specified font. + + DWRITE_FONT_WEIGHT IDWriteFont::GetWeight() + + + + Gets the stretch, or width, of the specified font. + + DWRITE_FONT_STRETCH IDWriteFont::GetStretch() + + + + Gets the style, or slope, of the specified font. + + DWRITE_FONT_STYLE IDWriteFont::GetStyle() + + + + Determines whether the font is a symbol font. + + BOOL IDWriteFont::IsSymbolFont() + + + + Gets a localized strings collection containing the face names for the font (such as Regular or Bold), indexed by locale name. + + HRESULT IDWriteFont::GetFaceNames([Out] IDWriteLocalizedStrings** names) + + + + Gets a value that indicates what simulations are applied to the specified font. + + DWRITE_FONT_SIMULATIONS IDWriteFont::GetSimulations() + + + + Obtains design units and common metrics for the font face. These metrics are applicable to all the glyphs within a font face and are used by applications for layout calculations. + + void IDWriteFont::GetMetrics([Out] DWRITE_FONT_METRICS* fontMetrics) + + + + An object that encapsulates a set of fonts, such as the set of fonts installed on the system, or the set of fonts in a particular directory. The font collection API can be used to discover what font families and fonts are available, and to obtain some metadata about the fonts. + + IDWriteFontCollection + + + + Creates a font collection using a custom font collection loader. + + A reference to a DirectWrite factory + An application-defined font collection loader, which must have been previously registered using . + The key used by the loader to identify a collection of font files. The buffer allocated for this key should at least be the size of collectionKeySize. + HRESULT IDWriteFactory::CreateCustomFontCollection([None] IDWriteFontCollectionLoader* collectionLoader,[In, Buffer] const void* collectionKey,[None] int collectionKeySize,[Out] IDWriteFontCollection** fontCollection) + + + + Finds the font family with the specified family name. + + An array of characters, which is null-terminated, containing the name of the font family. The name is not case-sensitive but must otherwise exactly match a family name in the collection. + When this method returns, contains the zero-based index of the matching font family if the family name was found; otherwise, UINT_MAX. + TRUE if the family name exists; otherwise, FALSE. + HRESULT IDWriteFontCollection::FindFamilyName([In] const wchar_t* familyName,[Out] int* index,[Out] BOOL* exists) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Gets the number of font families in the collection. + + The number of font families in the collection. + int IDWriteFontCollection::GetFontFamilyCount() + + + + Creates a font family object given a zero-based font family index. + + Zero-based index of the font family. + When this method returns, contains the address of a reference to the newly created font family object. + HRESULT IDWriteFontCollection::GetFontFamily([None] int index,[Out] IDWriteFontFamily** fontFamily) + + + + Finds the font family with the specified family name. + + An array of characters, which is null-terminated, containing the name of the font family. The name is not case-sensitive but must otherwise exactly match a family name in the collection. + When this method returns, contains the zero-based index of the matching font family if the family name was found; otherwise, UINT_MAX. + When this method returns, TRUE if the family name exists; otherwise, FALSE. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontCollection::FindFamilyName([In] const wchar_t* familyName,[Out] int* index,[Out] BOOL* exists) + + + + Gets the font object that corresponds to the same physical font as the specified font face object. The specified physical font must belong to the font collection. + + A font face object that specifies the physical font. + When this method returns, contains the address of a reference to the newly created font object if successful; otherwise, NULL. + HRESULT IDWriteFontCollection::GetFontFromFontFace([None] IDWriteFontFace* fontFace,[Out] IDWriteFont** font) + + + + Gets the number of font families in the collection. + + int IDWriteFontCollection::GetFontFamilyCount() + + + + Used to construct a collection of fonts given a particular type of key. + + IDWriteFontCollectionLoader + + + + Creates a font file enumerator object that encapsulates a collection of font files. The font system calls back to this interface to create a font collection. + + Pointer to the object that was used to create the current font collection. + A font collection key that uniquely identifies the collection of font files within the scope of the font collection loader being used. The buffer allocated for this key must be at least the size, in bytes, specified by collectionKeySize. + a reference to the newly created font file enumerator. + HRESULT IDWriteFontCollectionLoader::CreateEnumeratorFromKey([None] IDWriteFactory* factory,[In, Buffer] const void* collectionKey,[None] int collectionKeySize,[Out] IDWriteFontFileEnumerator** fontFileEnumerator) + + + + Internal FontCollectionLoader Callback + + + + + Initializes a new instance of the class. + + The factory. + The callback. + + + + Gets or sets the callback. + + The callback. + + + HRESULT IDWriteFontCollectionLoader::CreateEnumeratorFromKey([None] IDWriteFactory* factory,[In, Buffer] const void* collectionKey,[None] int collectionKeySize,[Out] IDWriteFontFileEnumerator** fontFileEnumerator) + + + + Represents an absolute reference to a font face which contains font face type, appropriate file references, face identification data and various font data such as metrics, names and glyph outlines. + + IDWriteFontFace + + + + Creates an object that represents a font face. + + A reference to a DirectWrite factory + A value that indicates the type of file format of the font face. + A font file object representing the font face. Because maintains its own references to the input font file objects, you may release them after this call. + The zero-based index of a font face, in cases when the font files contain a collection of font faces. If the font files contain a single face, this value should be zero. + A value that indicates which, if any, font face simulation flags for algorithmic means of making text bold or italic are applied to the current font face. + HRESULT IDWriteFactory::CreateFontFace([None] DWRITE_FONT_FACE_TYPE fontFaceType,[None] int numberOfFiles,[In, Buffer] const IDWriteFontFile** fontFiles,[None] int faceIndex,[None] DWRITE_FONT_SIMULATIONS fontFaceSimulationFlags,[Out] IDWriteFontFace** fontFace) + + + + Creates a font face object for the font. + + the to create the FontFace from. + HRESULT IDWriteFont::CreateFontFace([Out] IDWriteFontFace** fontFace) + + + + Obtains ideal (resolution-independent) glyph metrics in font design units. + + + Design glyph metrics are used for glyph positioning. + + An array of glyph indices for which to compute metrics. The array must contain at least as many elements as specified by glyphCount. + Indicates whether the font is being used in a sideways run. This can affect the glyph metrics if the font has oblique simulation because sideways oblique simulation differs from non-sideways oblique simulation + an array of structures. + HRESULT IDWriteFontFace::GetDesignGlyphMetrics([In, Buffer] const short* glyphIndices,[None] int glyphCount,[Out, Buffer] DWRITE_GLYPH_METRICS* glyphMetrics,[None] BOOL isSideways) + + + + Obtains glyph metrics in font design units with the return values compatible with what GDI would produce. + + The ogical size of the font in DIP units. + The number of physical pixels per DIP. + An optional transform applied to the glyphs and their positions. This transform is applied after the scaling specified by the font size and pixelsPerDip. + When set to FALSE, the metrics are the same as the metrics of GDI aliased text. When set to TRUE, the metrics are the same as the metrics of text measured by GDI using a font created with CLEARTYPE_NATURAL_QUALITY. + An array of glyph indices for which to compute the metrics. + A BOOL value that indicates whether the font is being used in a sideways run. This can affect the glyph metrics if the font has oblique simulation because sideways oblique simulation differs from non-sideways oblique simulation. + An array of structures filled by this function. The metrics are in font design units. + HRESULT IDWriteFontFace::GetGdiCompatibleGlyphMetrics([None] float emSize,[None] float pixelsPerDip,[In, Optional] const DWRITE_MATRIX* transform,[None] BOOL useGdiNatural,[In, Buffer] const short* glyphIndices,[None] int glyphCount,[Out, Buffer] DWRITE_GLYPH_METRICS* glyphMetrics,[None] BOOL isSideways) + + + + Returns the nominal mapping of UCS4 Unicode code points to glyph indices as defined by the font 'CMAP' table. + + + Note that this mapping is primarily provided for line layout engines built on top of the physical font API. Because of OpenType glyph substitution and line layout character substitution, the nominal conversion does not always correspond to how a Unicode string will map to glyph indices when rendering using a particular font face. Also, note that Unicode variant selectors provide for alternate mappings for character to glyph. This call will always return the default variant. + + An array of USC4 code points from which to obtain nominal glyph indices. The array must be allocated and be able to contain the number of elements specified by codePointCount. + a reference to an array of nominal glyph indices filled by this function. + HRESULT IDWriteFontFace::GetGlyphIndices([In, Buffer] const int* codePoints,[None] int codePointCount,[Out, Buffer] short* glyphIndices) + + + + Obtains the font files representing a font face. + + + The IDWriteFontFace::GetFiles method should be called twice. The first time you call GetFilesfontFiles should be NULL. When the method returns, numberOfFiles receives the number of font files that represent the font face. Then, call the method a second time, passing the numberOfFiles value that was output the first call, and a non-null buffer of the correct size to store the references. + + An array that stores references to font files representing the font face. This parameter can be NULL if the user wants only the number of files representing the font face. This API increments reference count of the font file references returned according to COM conventions, and the client should release them when finished. + HRESULT IDWriteFontFace::GetFiles([InOut] int* numberOfFiles,[Out, Buffer, Optional] IDWriteFontFile** fontFiles) + + + + Finds the specified OpenType font table if it exists and returns a reference to it. The function accesses the underlying font data through the interface implemented by the font file loader. + + + The context for the same tag may be different for each call, so each one must be held and released separately. + + The four-character tag of a OpenType font table to find. Use the DWRITE_MAKE_OPENTYPE_TAG macro to create it as an UINT32. Unlike GDI, it does not support the special TTCF and null tags to access the whole font. + When this method returns, contains the address of a reference to the base of the table in memory. The reference is valid only as long as the font face used to get the font table still exists; (not any other font face, even if it actually refers to the same physical font). + When this method returns, the address of a reference to the opaque context, which must be freed by calling {{ReleaseFontTable}}. The context actually comes from the lower-level , which may be implemented by the application or DWrite itself. It is possible for a NULL tableContext to be returned, especially if the implementation performs direct memory mapping on the whole file. Nevertheless, always release it later, and do not use it as a test for function success. The same table can be queried multiple times, but because each returned context can be different, you must release each context separately. + TRUE if the font table exists; otherwise, FALSE. + HRESULT IDWriteFontFace::TryGetFontTable([In] int openTypeTableTag,[Out, Buffer] const void** tableData,[Out] int* tableSize,[Out] void** tableContext,[Out] BOOL* exists) + + + + Computes the outline of a run of glyphs by calling back to the outline sink interface. + + The logical size of the font in DIP units. A DIP ("device-independent pixel") equals 1/96 inch. + An array of glyph indices. The glyphs are in logical order and the advance direction depends on the isRightToLeft parameter. The array must be allocated and be able to contain the number of elements specified by glyphCount. + An optional array of glyph advances in DIPs. The advance of a glyph is the amount to advance the position (in the direction of the baseline) after drawing the glyph. glyphAdvances contains the number of elements specified by glyphIndices.Length. + An optional array of glyph offsets, each of which specifies the offset along the baseline and offset perpendicular to the baseline of a glyph relative to the current pen position. glyphOffsets contains the number of elements specified by glyphIndices.Length. + If TRUE, the ascender of the glyph runs alongside the baseline. If FALSE, the glyph ascender runs perpendicular to the baseline. For example, an English alphabet on a vertical baseline would have isSideways set to FALSE. A client can render a vertical run by setting isSideways to TRUE and rotating the resulting geometry 90 degrees to the right using a transform. The isSideways and isRightToLeft parameters cannot both be true. + The visual order of the glyphs. If this parameter is FALSE, then glyph advances are from left to right. If TRUE, the advance direction is right to left. By default, the advance direction is left to right. + A reference to the interface that is called back to perform outline drawing operations. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontFace::GetGlyphRunOutline([None] float emSize,[In, Buffer] const short* glyphIndices,[In, Buffer, Optional] const float* glyphAdvances,[In, Buffer, Optional] const DWRITE_GLYPH_OFFSET* glyphOffsets,[None] int glyphCount,[None] BOOL isSideways,[None] BOOL isRightToLeft,[None] IDWriteGeometrySink* geometrySink) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Obtains the file format type of a font face. + + A value that indicates the type of format for the font face (such as Type 1, TrueType, vector, or bitmap). + DWRITE_FONT_FACE_TYPE IDWriteFontFace::GetType() + + + + Obtains the font files representing a font face. + + + The IDWriteFontFace::GetFiles method should be called twice. The first time you call GetFilesfontFiles should be NULL. When the method returns, numberOfFiles receives the number of font files that represent the font face. Then, call the method a second time, passing the numberOfFiles value that was output the first call, and a non-null buffer of the correct size to store the references. + + If fontFiles is NULL, receives the number of files representing the font face. Otherwise, the number of font files being requested should be passed. See the Remarks section below for more information. + When this method returns, contains a reference to a user-provided array that stores references to font files representing the font face. This parameter can be NULL if the user wants only the number of files representing the font face. This API increments reference count of the font file references returned according to COM conventions, and the client should release them when finished. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontFace::GetFiles([InOut] int* numberOfFiles,[Out, Buffer, Optional] IDWriteFontFile** fontFiles) + + + + Obtains the index of a font face in the context of its font files. + + The zero-based index of a font face in cases when the font files contain a collection of font faces. If the font files contain a single face, this value is zero. + int IDWriteFontFace::GetIndex() + + + + Obtains the algorithmic style simulation flags of a font face. + + Font face simulation flags for algorithmic means of making text bold or italic. + DWRITE_FONT_SIMULATIONS IDWriteFontFace::GetSimulations() + + + + Determines whether the font is a symbol font. + + Returns TRUE if the font is a symbol font, otherwise FALSE. + BOOL IDWriteFontFace::IsSymbolFont() + + + + Obtains design units and common metrics for the font face. These metrics are applicable to all the glyphs within a font face and are used by applications for layout calculations. + + When this method returns, a? structure that holds metrics (such as ascent, descent, or cap height) for the current font face element. The metrics returned by this function are in font design units. + void IDWriteFontFace::GetMetrics([Out] DWRITE_FONT_METRICS* fontFaceMetrics) + + + + Obtains the number of glyphs in the font face. + + The number of glyphs in the font face. + short IDWriteFontFace::GetGlyphCount() + + + + Obtains ideal (resolution-independent) glyph metrics in font design units. + + + Design glyph metrics are used for glyph positioning. + + An array of glyph indices for which to compute metrics. The array must contain at least as many elements as specified by glyphCount. + The number of elements in the glyphIndices array. + When this method returns, contains an array of DWRITE_GLYPH_METRICS structures. glyphMetrics must be initialized with an empty buffer that contains at least as many elements as glyphCount. The metrics returned by this function are in font design units. + Indicates whether the font is being used in a sideways run. This can affect the glyph metrics if the font has oblique simulation because sideways oblique simulation differs from non-sideways oblique simulation + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontFace::GetDesignGlyphMetrics([In, Buffer] const short* glyphIndices,[None] int glyphCount,[Out, Buffer] DWRITE_GLYPH_METRICS* glyphMetrics,[None] BOOL isSideways) + + + + Returns the nominal mapping of UCS4 Unicode code points to glyph indices as defined by the font 'CMAP' table. + + + Note that this mapping is primarily provided for line layout engines built on top of the physical font API. Because of OpenType glyph substitution and line layout character substitution, the nominal conversion does not always correspond to how a Unicode string will map to glyph indices when rendering using a particular font face. Also, note that Unicode variant selectors provide for alternate mappings for character to glyph. This call will always return the default variant. + + An array of USC4 code points from which to obtain nominal glyph indices. The array must be allocated and be able to contain the number of elements specified by codePointCount. + The number of elements in the codePoints array. + When this method returns, contains a reference to an array of nominal glyph indices filled by this function. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontFace::GetGlyphIndices([In, Buffer] const int* codePoints,[None] int codePointCount,[Out, Buffer] short* glyphIndices) + + + + Finds the specified OpenType font table if it exists and returns a reference to it. The function accesses the underlying font data through the interface implemented by the font file loader. + + + The context for the same tag may be different for each call, so each one must be held and released separately. + + The four-character tag of a OpenType font table to find. Use the DWRITE_MAKE_OPENTYPE_TAG macro to create it as an UINT32. Unlike GDI, it does not support the special TTCF and null tags to access the whole font. + When this method returns, contains the address of a reference to the base of the table in memory. The reference is valid only as long as the font face used to get the font table still exists; (not any other font face, even if it actually refers to the same physical font). This parameter is passed uninitialized. + When this method returns, contains a reference to the size, in bytes, of the font table. + When this method returns, the address of a reference to the opaque context, which must be freed by calling {{ReleaseFontTable}}. The context actually comes from the lower-level , which may be implemented by the application or DWrite itself. It is possible for a NULL tableContext to be returned, especially if the implementation performs direct memory mapping on the whole file. Nevertheless, always release it later, and do not use it as a test for function success. The same table can be queried multiple times, but because each returned context can be different, you must release each context separately. + When this method returns, TRUE if the font table exists; otherwise, FALSE. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontFace::TryGetFontTable([In] int openTypeTableTag,[Out, Buffer] const void** tableData,[Out] int* tableSize,[Out] void** tableContext,[Out] BOOL* exists) + + + + Releases the table obtained earlier from {{TryGetFontTable}}. + + A reference to the opaque context from {{TryGetFontTable}}. + void IDWriteFontFace::ReleaseFontTable([In] void* tableContext) + + + + Computes the outline of a run of glyphs by calling back to the outline sink interface. + + The logical size of the font in DIP units. A DIP ("device-independent pixel") equals 1/96 inch. + An array of glyph indices. The glyphs are in logical order and the advance direction depends on the isRightToLeft parameter. The array must be allocated and be able to contain the number of elements specified by glyphCount. + An optional array of glyph advances in DIPs. The advance of a glyph is the amount to advance the position (in the direction of the baseline) after drawing the glyph. glyphAdvances contains the number of elements specified by glyphCount. + An optional array of glyph offsets, each of which specifies the offset along the baseline and offset perpendicular to the baseline of a glyph relative to the current pen position. glyphOffsets contains the number of elements specified by glyphCount. + The number of glyphs in the run. + If TRUE, the ascender of the glyph runs alongside the baseline. If FALSE, the glyph ascender runs perpendicular to the baseline. For example, an English alphabet on a vertical baseline would have isSideways set to FALSE. A client can render a vertical run by setting isSideways to TRUE and rotating the resulting geometry 90 degrees to the right using a transform. The isSideways and isRightToLeft parameters cannot both be true. + The visual order of the glyphs. If this parameter is FALSE, then glyph advances are from left to right. If TRUE, the advance direction is right to left. By default, the advance direction is left to right. + A reference to the interface that is called back to perform outline drawing operations. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontFace::GetGlyphRunOutline([None] float emSize,[In, Buffer] const short* glyphIndices,[In, Buffer, Optional] const float* glyphAdvances,[In, Buffer, Optional] const DWRITE_GLYPH_OFFSET* glyphOffsets,[None] int glyphCount,[None] BOOL isSideways,[None] BOOL isRightToLeft,[None] IDWriteGeometrySink* geometrySink) + + + + Determines the recommended rendering mode for the font, using the specified size and rendering parameters. + + The logical size of the font in DIP units. A DIP ("device-independent pixel") equals 1/96 inch. + The number of physical pixels per DIP. For example, if the DPI of the rendering surface is 96, this value is 1.0f. If the DPI is 120, this value is 120.0f/96. + The measuring method that will be used for glyphs in the font. Renderer implementations may choose different rendering modes for different measuring methods, for example: DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL for DWRITE_MEASURING_MODE_NATURAL DWRITE_RENDERING_MODE_CLEARTYPE_GDI_CLASSIC for DWRITE_MEASURING_MODE_GDI_CLASSIC DWRITE_RENDERING_MODE_CLEARTYPE_GDI_NATURAL for DWRITE_MEASURING_MODE_GDI_NATURAL + A reference to an object that contains rendering settings such as gamma level, enhanced contrast, and ClearType level. This parameter is necessary in case the rendering parameters object overrides the rendering mode. + When this method returns, contains a value that indicates the recommended rendering mode to use. + HRESULT IDWriteFontFace::GetRecommendedRenderingMode([None] float emSize,[None] float pixelsPerDip,[None] DWRITE_MEASURING_MODE measuringMode,[None] IDWriteRenderingParams* renderingParams,[Out] DWRITE_RENDERING_MODE* renderingMode) + + + + Obtains design units and common metrics for the font face. These metrics are applicable to all the glyphs within a fontface and are used by applications for layout calculations. + + The logical size of the font in DIP units. + The number of physical pixels per DIP. + An optional transform applied to the glyphs and their positions. This transform is applied after the scaling specified by the font size and pixelsPerDip. + A reference to a {{DWRITE_FONT_METRIC}}S structure to fill in. The metrics returned by this function are in font design units. + HRESULT IDWriteFontFace::GetGdiCompatibleMetrics([None] float emSize,[None] float pixelsPerDip,[In, Optional] const DWRITE_MATRIX* transform,[Out] DWRITE_FONT_METRICS* fontFaceMetrics) + + + + Obtains glyph metrics in font design units with the return values compatible with what GDI would produce. + + The ogical size of the font in DIP units. + The number of physical pixels per DIP. + An optional transform applied to the glyphs and their positions. This transform is applied after the scaling specified by the font size and pixelsPerDip. + When set to FALSE, the metrics are the same as the metrics of GDI aliased text. When set to TRUE, the metrics are the same as the metrics of text measured by GDI using a font created with CLEARTYPE_NATURAL_QUALITY. + An array of glyph indices for which to compute the metrics. + The number of elements in the glyphIndices array. + An array of structures filled by this function. The metrics are in font design units. + A BOOL value that indicates whether the font is being used in a sideways run. This can affect the glyph metrics if the font has oblique simulation because sideways oblique simulation differs from non-sideways oblique simulation. + Standard HRESULT error code. If any of the input glyph indices are outside of the valid glyph index range for the current font face, E_INVALIDARG will be returned. + HRESULT IDWriteFontFace::GetGdiCompatibleGlyphMetrics([None] float emSize,[None] float pixelsPerDip,[In, Optional] const DWRITE_MATRIX* transform,[None] BOOL useGdiNatural,[In, Buffer] const short* glyphIndices,[None] int glyphCount,[Out, Buffer] DWRITE_GLYPH_METRICS* glyphMetrics,[None] BOOL isSideways) + + + + Obtains the file format type of a font face. + + DWRITE_FONT_FACE_TYPE IDWriteFontFace::GetType() + + + + Obtains the index of a font face in the context of its font files. + + int IDWriteFontFace::GetIndex() + + + + Obtains the algorithmic style simulation flags of a font face. + + DWRITE_FONT_SIMULATIONS IDWriteFontFace::GetSimulations() + + + + Determines whether the font is a symbol font. + + BOOL IDWriteFontFace::IsSymbolFont() + + + + Obtains design units and common metrics for the font face. These metrics are applicable to all the glyphs within a font face and are used by applications for layout calculations. + + void IDWriteFontFace::GetMetrics([Out] DWRITE_FONT_METRICS* fontFaceMetrics) + + + + Obtains the number of glyphs in the font face. + + short IDWriteFontFace::GetGlyphCount() + + + + Specifies properties used to identify and execute typographic features in the current font face. + + + A non-zero value generally enables the feature execution, while the zero value disables it. A feature requiring a selector uses this value to indicate the selector index. The OpenType standard provides access to typographic features available in the font by means of a feature tag with the associated parameters. The OpenType feature tag is a 4-byte identifier of the registered name of a feature. For example, the 'kern' feature name tag is used to identify the 'Kerning' feature in OpenType font. Similarly, the OpenType feature tag for 'Standard Ligatures' and 'Fractions' is 'liga' and 'frac' respectively. Since a single run can be associated with more than one typographic features, the Text String API accepts typographic settings for a run as a list of features and are executed in the order they are specified. The value of the tag member represents the OpenType name tag of the feature, while the param value represents additional parameter for the execution of the feature referred by the tag member. Both nameTag and parameter are stored as little endian, the same convention followed by GDI. Most features treat the Param value as a binary value that indicates whether to turn the execution of the feature on or off, with it being off by default in the majority of cases. Some features, however, treat this value as an integral value representing the integer index to the list of alternate results it may produce during the execution; for instance, the feature 'Stylistic Alternates' or 'salt' uses the parameter value as an index to the list of alternate substituting glyphs it could produce for a specified glyph. + + DWRITE_FONT_FEATURE + + + + Initializes a new instance of the struct. + + The name tag. + The parameter. + + + + The feature OpenType name identifier. + + DWRITE_FONT_FEATURE_TAG nameTag + + + + The execution parameter of the feature. + + int parameter + + + + Represents a font file. Applications such as font managers or font viewers can call to find out if a particular file is a font file, and whether it is a font type that is supported by the font system. + + IDWriteFontFile + + + + Creates a font file reference object from a local font file. + + A reference to a DirectWrite factory + An array of characters that contains the absolute file path for the font file. Subsequent operations on the constructed object may fail if the user provided filePath doesn't correspond to a valid file on the disk. + HRESULT IDWriteFactory::CreateFontFileReference([In] const wchar_t* filePath,[In, Optional] const __int64* lastWriteTime,[Out] IDWriteFontFile** fontFile) + + + + Creates a font file reference object from a local font file. + + A reference to a DirectWrite factory + An array of characters that contains the absolute file path for the font file. Subsequent operations on the constructed object may fail if the user provided filePath doesn't correspond to a valid file on the disk. + The last modified time of the input file path. If the parameter is omitted, the function will access the font file to obtain its last write time. You should specify this value to avoid extra disk access. Subsequent operations on the constructed object may fail if the user provided lastWriteTime doesn't match the file on the disk. + HRESULT IDWriteFactory::CreateFontFileReference([In] const wchar_t* filePath,[In, Optional] const __int64* lastWriteTime,[Out] IDWriteFontFile** fontFile) + + + + Creates a reference to an application-specific font file resource. + + A reference to a DirectWrite factory + A font file reference key that uniquely identifies the font file resource during the lifetime of fontFileLoader. + The size of the font file reference key in bytes. + The font file loader that will be used by the font system to load data from the file identified by fontFileReferenceKey. + + This function is provided for cases when an application or a document needs to use a private font without having to install it on the system. fontFileReferenceKey has to be unique only in the scope of the fontFileLoader used in this call. + + HRESULT IDWriteFactory::CreateCustomFontFileReference([In, Buffer] const void* fontFileReferenceKey,[None] int fontFileReferenceKeySize,[None] IDWriteFontFileLoader* fontFileLoader,[Out] IDWriteFontFile** fontFile) + + + + Obtains the reference to the reference key of a font file. The returned reference is valid until the font file object is released. + + the reference to the reference key of a font file. + HRESULT IDWriteFontFile::GetReferenceKey([Out, Buffer] const void** fontFileReferenceKey,[Out] int* fontFileReferenceKeySize) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Obtains the reference to the reference key of a font file. The returned reference is valid until the font file object is released. + + When this method returns, contains an address of a reference to the font file reference key. Note that the reference value is only valid until the font file object it is obtained from is released. This parameter is passed uninitialized. + When this method returns, contains the size of the font file reference key in bytes. This parameter is passed uninitialized. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontFile::GetReferenceKey([Out, Buffer] const void** fontFileReferenceKey,[Out] int* fontFileReferenceKeySize) + + + + Obtains the file loader associated with a font file object. + + When this method returns, contains the address of a reference to the font file loader associated with the font file object. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontFile::GetLoader([Out] IDWriteFontFileLoader** fontFileLoader) + + + + Analyzes a file and returns whether it represents a font, and whether the font type is supported by the font system. + + + IMPORTANT: Certain font file types are recognized, but not supported by the font system. For example, the font system will recognize a file as a Type 1 font file but will not be able to construct a font face object from it. In such situations, Analyze will set isSupportedFontType output parameter to FALSE. + + TRUE if the font type is supported by the font system; otherwise, FALSE. + When this method returns, contains a value that indicates the type of the font file. Note that even if isSupportedFontType is FALSE, the fontFileType value may be different from DWRITE_FONT_FILE_TYPE_UNKNOWN. + When this method returns, contains a value that indicates the type of the font face. If fontFileType is not equal to DWRITE_FONT_FILE_TYPE_UNKNOWN, then that can be constructed from the font file. + When this method returns, contains the number of font faces contained in the font file. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontFile::Analyze([Out] BOOL* isSupportedFontType,[Out] DWRITE_FONT_FILE_TYPE* fontFileType,[Out, Optional] DWRITE_FONT_FACE_TYPE* fontFaceType,[Out] int* numberOfFaces) + + + + Obtains the file loader associated with a font file object. + + HRESULT IDWriteFontFile::GetLoader([Out] IDWriteFontFileLoader** fontFileLoader) + + + + Encapsulates a collection of font files. The font system uses this interface to enumerate font files when building a font collection. + + IDWriteFontFileEnumerator + + + + Advances to the next font file in the collection. When it is first created, the enumerator is positioned before the first element of the collection and the first call to MoveNext advances to the first file. + + the value TRUE if the enumerator advances to a file; otherwise, FALSE if the enumerator advances past the last file in the collection. + HRESULT IDWriteFontFileEnumerator::MoveNext([Out] BOOL* hasCurrentFile) + + + + Gets a reference to the current font file. + + a reference to the newly created object. + HRESULT IDWriteFontFileEnumerator::GetCurrentFontFile([Out] IDWriteFontFile** fontFile) + + + + Internal FontFileEnumerator Callback + + + + + Initializes a new instance of the class. + + The callback. + + + + Gets or sets the callback. + + The callback. + + + + Advances to the next font file in the collection. When it is first created, the enumerator is positioned before the first element of the collection and the first call to MoveNext advances to the first file. + + the value TRUE if the enumerator advances to a file; otherwise, FALSE if the enumerator advances past the last file in the collection. + HRESULT IDWriteFontFileEnumerator::MoveNext([Out] BOOL* hasCurrentFile) + + + + Gets a reference to the current font file. + + a reference to the newly created object. + HRESULT IDWriteFontFileEnumerator::GetCurrentFontFile([Out] IDWriteFontFile** fontFile) + + + + Handles loading font file resources of a particular type from a font file reference key into a font file stream object. + + IDWriteFontFileLoader + + + + Creates a font file stream object that encapsulates an open file resource. + + + The resource is closed when the last reference to fontFileStream is released. + + A reference to a font file reference key that uniquely identifies the font file resource within the scope of the font loader being used. The buffer allocated for this key must at least be the size, in bytes, specified by fontFileReferenceKeySize. + a reference to the newly created object. + HRESULT IDWriteFontFileLoader::CreateStreamFromKey([In, Buffer] const void* fontFileReferenceKey,[None] int fontFileReferenceKeySize,[Out] IDWriteFontFileStream** fontFileStream) + + + + Internal FontFileLoader Callback + + + + + Initializes a new instance of the class. + + The callback. + + + + Gets or sets the callback. + + The callback. + + + HRESULT IDWriteFontFileLoader::CreateStreamFromKey([In, Buffer] const void* fontFileReferenceKey,[None] int fontFileReferenceKeySize,[Out] IDWriteFontFileStream** fontFileStream) + + + + Handles loading font file resources of a particular type from a font file reference key into a font file stream object. + + IDWriteFontFileLoader + + + + Creates a font file stream object that encapsulates an open file resource. + + + The resource is closed when the last reference to fontFileStream is released. + + A reference to a font file reference key that uniquely identifies the font file resource within the scope of the font loader being used. The buffer allocated for this key must at least be the size, in bytes, specified by fontFileReferenceKeySize. + a reference to the newly created object. + HRESULT IDWriteFontFileLoader::CreateStreamFromKey([In, Buffer] const void* fontFileReferenceKey,[None] int fontFileReferenceKeySize,[Out] IDWriteFontFileStream** fontFileStream) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Creates a font file stream object that encapsulates an open file resource. + + + The resource is closed when the last reference to fontFileStream is released. + + A reference to a font file reference key that uniquely identifies the font file resource within the scope of the font loader being used. The buffer allocated for this key must at least be the size, in bytes, specified by fontFileReferenceKeySize. + The size of font file reference key, in bytes. + When this method returns, contains the address of a reference to the newly created object. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontFileLoader::CreateStreamFromKey([In, Buffer] const void* fontFileReferenceKey,[None] int fontFileReferenceKeySize,[Out] IDWriteFontFileStream** fontFileStream) + + + + Loads font file data from a custom font file loader. + + IDWriteFontFileStream + + + + Reads a fragment from a font file. + + + Note that ReadFileFragment implementations must check whether the requested font file fragment is within the file bounds. Otherwise, an error should be returned from ReadFileFragment. {{DirectWrite}} may invoke methods on the same object from multiple threads simultaneously. Therefore, ReadFileFragment implementations that rely on internal mutable state must serialize access to such state across multiple threads. For example, an implementation that uses separate Seek and Read operations to read a file fragment must place the code block containing Seek and Read calls under a lock or a critical section. + + When this method returns, contains an address of a reference to the start of the font file fragment. This parameter is passed uninitialized. + The offset of the fragment, in bytes, from the beginning of the font file. + The size of the file fragment, in bytes. + When this method returns, contains the address of + a reference to a reference to the client-defined context to be passed to {{ReleaseFileFragment}}. + HRESULT IDWriteFontFileStream::ReadFileFragment([Out, Buffer] const void** fragmentStart,[None] __int64 fileOffset,[None] __int64 fragmentSize,[Out] void** fragmentContext) + + + + Releases a fragment from a file. + + A reference to the client-defined context of a font fragment returned from {{ReadFileFragment}}. + void IDWriteFontFileStream::ReleaseFileFragment([None] void* fragmentContext) + + + + Obtains the total size of a file. + + + Implementing GetFileSize() for asynchronously loaded font files may require downloading the complete file contents. Therefore, this method should be used only for operations that either require a complete font file to be loaded (for example, copying a font file) or that need to make decisions based on the value of the file size (for example, validation against a persisted file size). + + the total size of the file. + HRESULT IDWriteFontFileStream::GetFileSize([Out] __int64* fileSize) + + + + Obtains the last modified time of the file. + + + The "last modified time" is used by DirectWrite font selection algorithms to determine whether one font resource is more up to date than another one. + + the last modified time of the file in the format that represents the number of 100-nanosecond intervals since January 1, 1601 (UTC). + HRESULT IDWriteFontFileStream::GetLastWriteTime([Out] __int64* lastWriteTime) + + + + Internal FontFileStream Callback + + + + + Initializes a new instance of the class. + + The callback. + + + + Gets or sets the callback. + + The callback. + + + HRESULT IDWriteFontFileStream::ReadFileFragment([Out, Buffer] const void** fragmentStart,[None] __int64 fileOffset,[None] __int64 fragmentSize,[Out] void** fragmentContext) + + + void IDWriteFontFileStream::ReleaseFileFragment([None] void* fragmentContext) + + + HRESULT IDWriteFontFileStream::GetFileSize([Out] __int64* fileSize) + + + HRESULT IDWriteFontFileStream::GetLastWriteTime([Out] __int64* lastWriteTime) + + + + Loads font file data from a custom font file loader. + + IDWriteFontFileStream + + + + Reads a fragment from a font file. + + + Note that ReadFileFragment implementations must check whether the requested font file fragment is within the file bounds. Otherwise, an error should be returned from ReadFileFragment. {{DirectWrite}} may invoke methods on the same object from multiple threads simultaneously. Therefore, ReadFileFragment implementations that rely on internal mutable state must serialize access to such state across multiple threads. For example, an implementation that uses separate Seek and Read operations to read a file fragment must place the code block containing Seek and Read calls under a lock or a critical section. + + When this method returns, contains an address of a reference to the start of the font file fragment. This parameter is passed uninitialized. + The offset of the fragment, in bytes, from the beginning of the font file. + The size of the file fragment, in bytes. + When this method returns, contains the address of + a reference to a reference to the client-defined context to be passed to {{ReleaseFileFragment}}. + HRESULT IDWriteFontFileStream::ReadFileFragment([Out, Buffer] const void** fragmentStart,[None] __int64 fileOffset,[None] __int64 fragmentSize,[Out] void** fragmentContext) + + + + Releases a fragment from a file. + + A reference to the client-defined context of a font fragment returned from {{ReadFileFragment}}. + void IDWriteFontFileStream::ReleaseFileFragment([None] void* fragmentContext) + + + + Obtains the total size of a file. + + + Implementing GetFileSize() for asynchronously loaded font files may require downloading the complete file contents. Therefore, this method should be used only for operations that either require a complete font file to be loaded (for example, copying a font file) or that need to make decisions based on the value of the file size (for example, validation against a persisted file size). + + the total size of the file. + HRESULT IDWriteFontFileStream::GetFileSize([Out] __int64* fileSize) + + + + Obtains the last modified time of the file. + + + The "last modified time" is used by DirectWrite font selection algorithms to determine whether one font resource is more up to date than another one. + + the last modified time of the file in the format that represents the number of 100-nanosecond intervals since January 1, 1601 (UTC). + HRESULT IDWriteFontFileStream::GetLastWriteTime([Out] __int64* lastWriteTime) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Reads a fragment from a font file. + + + Note that ReadFileFragment implementations must check whether the requested font file fragment is within the file bounds. Otherwise, an error should be returned from ReadFileFragment. {{DirectWrite}} may invoke methods on the same object from multiple threads simultaneously. Therefore, ReadFileFragment implementations that rely on internal mutable state must serialize access to such state across multiple threads. For example, an implementation that uses separate Seek and Read operations to read a file fragment must place the code block containing Seek and Read calls under a lock or a critical section. + + When this method returns, contains an address of a reference to the start of the font file fragment. This parameter is passed uninitialized. + The offset of the fragment, in bytes, from the beginning of the font file. + The size of the file fragment, in bytes. + When this method returns, contains the address of a reference to a reference to the client-defined context to be passed to {{ReleaseFileFragment}}. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontFileStream::ReadFileFragment([Out] const void** fragmentStart,[None] __int64 fileOffset,[None] __int64 fragmentSize,[Out] void** fragmentContext) + + + + Releases a fragment from a file. + + A reference to the client-defined context of a font fragment returned from {{ReadFileFragment}}. + void IDWriteFontFileStream::ReleaseFileFragment([None] void* fragmentContext) + + + + Obtains the total size of a file. + + + Implementing GetFileSize() for asynchronously loaded font files may require downloading the complete file contents. Therefore, this method should be used only for operations that either require a complete font file to be loaded (for example, copying a font file) or that need to make decisions based on the value of the file size (for example, validation against a persisted file size). + + When this method returns, contains the total size of the file. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontFileStream::GetFileSize([Out] __int64* fileSize) + + + + Obtains the last modified time of the file. + + + The "last modified time" is used by DirectWrite font selection algorithms to determine whether one font resource is more up to date than another one. + + When this method returns, contains the last modified time of the file in the format that represents the number of 100-nanosecond intervals since January 1, 1601 (UTC). + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontFileStream::GetLastWriteTime([Out] __int64* lastWriteTime) + + + + Provides interoperability with GDI, such as methods to convert a font face to a LOGFONT structure, or to convert a GDI font description into a font face. It is also used to create bitmap render target objects. + + IDWriteGdiInterop + + + + Creates a font object that matches the properties specified by the LOGFONT structure. + + A structure containing a GDI-compatible font description. + a reference to a newly created . + HRESULT IDWriteGdiInterop::CreateFontFromLOGFONT([In] const LOGFONTW* logFont,[Out] IDWriteFont** font) + + + + Initializes a LOGFONT structure based on the GDI-compatible properties of the specified font. + + + The conversion to a LOGFONT by using ConvertFontToLOGFONT operates at the logical font level and does not guarantee that it will map to a specific physical font. It is not guaranteed that GDI will select the same physical font for displaying text formatted by a LOGFONT as the object that was converted. + + An object to be converted into a GDI-compatible LOGFONT structure. + When this method returns, contains a structure that receives a GDI-compatible font description. + TRUE if the specified font object is part of the system font collection; otherwise, FALSE. + HRESULT IDWriteGdiInterop::ConvertFontToLOGFONT([None] IDWriteFont* font,[In] LOGFONTW* logFont,[Out] BOOL* isSystemFont) + + + + Creates a font object that matches the properties specified by the LOGFONT structure. + + A description. + a reference to a newly created . + HRESULT IDWriteGdiInterop::CreateFontFromLOGFONT([In] const LOGFONTW* logFont,[Out] IDWriteFont** font) + + + + Convert a Direct2D to a . + + a Direct2D Font + a + true if the specified font object is part of the system font collection; otherwise, false. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Creates a font object that matches the properties specified by the LOGFONT structure. + + A structure containing a GDI-compatible font description. + When this method returns, contains an address of a reference to a newly created object if successful; otherwise, NULL. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteGdiInterop::CreateFontFromLOGFONT([In] const void* logFont,[Out] IDWriteFont** font) + + + + Initializes a LOGFONT structure based on the GDI-compatible properties of the specified font. + + + The conversion to a LOGFONT by using ConvertFontToLOGFONT operates at the logical font level and does not guarantee that it will map to a specific physical font. It is not guaranteed that GDI will select the same physical font for displaying text formatted by a LOGFONT as the object that was converted. + + An object to be converted into a GDI-compatible LOGFONT structure. + When this method returns, contains a structure that receives a GDI-compatible font description. + When this method returns, contains TRUE if the specified font object is part of the system font collection; otherwise, FALSE. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteGdiInterop::ConvertFontToLOGFONT([None] IDWriteFont* font,[In] void* logFont,[Out] BOOL* isSystemFont) + + + + Initializes a LOGFONT structure based on the GDI-compatible properties of the specified font. + + + The conversion to a LOGFONT by using ConvertFontFaceToLOGFONT operates at the logical font level and does not guarantee that it will map to a specific physical font. It is not guaranteed that GDI will select the same physical font for displaying text formatted by a LOGFONT as the object that was converted. + + An object to be converted into a GDI-compatible LOGFONT structure. + When this method returns, contains a reference to a structure that receives a GDI-compatible font description. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteGdiInterop::ConvertFontFaceToLOGFONT([None] IDWriteFontFace* font,[In] void* logFont) + + + + Creates an IDWriteFontFace object that corresponds to the currently selected HFONT of the specified HDC. + + + This function is intended for scenarios in which an application wants to use GDI and Uniscribe 1.x for text layout and shaping, but DirectWrite for final rendering. This function assumes the client is performing text output using glyph indexes. + + A handle to a device context into which a font has been selected. It is assumed that the client has already performed font mapping and that the font selected into the device context is the actual font to be used for rendering glyphs. + Contains an address of a reference to the newly created font face object, or NULL in case of failure. The font face returned is guaranteed to reference the same physical typeface that would be used for drawing glyphs (but not necessarily characters) using ExtTextOut. + HRESULT IDWriteGdiInterop::CreateFontFaceFromHdc([None] void* hdc,[Out] IDWriteFontFace** fontFace) + + + + Creates an object that encapsulates a bitmap and memory DC (device context) which can be used for rendering glyphs. + + A handle to the optional device context used to create a compatible memory DC (device context). + The width of the bitmap render target. + The height of the bitmap render target. + When this method returns, contains an address of a reference to the newly created object. + HRESULT IDWriteGdiInterop::CreateBitmapRenderTarget([In, Optional] void* hdc,[None] int width,[None] int height,[Out] IDWriteBitmapRenderTarget** renderTarget) + + + + Contains the information needed by renderers to draw glyph runs. All coordinates are in device independent pixels (DIPs). + + DWRITE_GLYPH_RUN + + + + Trannsform this GlyphRun to individual indices, advances and offsets arrays. + + The advances array. + The offsets array. + the indices array. + + + + The physical font face object to draw with. + + IDWriteFontFace* fontFace + + + + The logical size of the font in DIPs (equals 1/96 inch), not points. + + float fontEmSize + + + + The number of glyphs in the glyph run. + + int glyphCount + + + + A reference to an array of indices to render for the glyph run. + + const short* glyphIndices + + + + A reference to an array containing glyph advance widths for the glyph run. + + const float* glyphAdvances + + + + A reference to an array containing glyph offsets for the glyph run. + + const DWRITE_GLYPH_OFFSET* glyphOffsets + + + + The implicit resolved bidi level of the run. Odd levels indicate right-to-left languages like Hebrew and Arabic, while even levels indicate left-to-right languages like English and Japanese (when written horizontally). For right-to-left languages, the text origin is on the right, and text should be drawn to the left. + + int bidiLevel + + + + Gets or sets the associated with this GlypRun. + + The font face. + + + + Gets or sets an array containing glyph advance widths for the glyph run. + + The glyph advances. + + + + If true, specifies that glyphs are rotated 90 degrees to the left and vertical metrics are used. Vertical writing is achieved by specifying isSideways = true and rotating the entire run 90 degrees to the right via a rotate transform. + + BOOL isSideways + + + + Contains low-level information used to render a glyph run. + + IDWriteGlyphRunAnalysis + + + + Creates a glyph run analysis object, which encapsulates information used to render a glyph run. + + The factory. + A structure that contains the properties of the glyph run (font face, advances, and so on). + Number of physical pixels per DIP (device independent pixel). For example, if rendering onto a 96 DPI bitmap then pixelsPerDip is 1. If rendering onto a 120 DPI bitmap then pixelsPerDip is 1.25. + A value that specifies the rendering mode, which must be one of the raster rendering modes (that is, not default and not outline). + Specifies the measuring mode to use with glyphs. + The horizontal position (X-coordinate) of the baseline origin, in DIPs. + Vertical position (Y-coordinate) of the baseline origin, in DIPs. + + The glyph run analysis object contains the results of analyzing the glyph run, including the positions of all the glyphs and references to all of the rasterized glyphs in the font cache. + + HRESULT IDWriteFactory::CreateGlyphRunAnalysis([In] const DWRITE_GLYPH_RUN* glyphRun,[None] float pixelsPerDip,[In, Optional] const DWRITE_MATRIX* transform,[None] DWRITE_RENDERING_MODE renderingMode,[None] DWRITE_MEASURING_MODE measuringMode,[None] float baselineOriginX,[None] float baselineOriginY,[Out] IDWriteGlyphRunAnalysis** glyphRunAnalysis) + + + + Creates a glyph run analysis object, which encapsulates information used to render a glyph run. + + The factory. + A structure that contains the properties of the glyph run (font face, advances, and so on). + Number of physical pixels per DIP (device independent pixel). For example, if rendering onto a 96 DPI bitmap then pixelsPerDip is 1. If rendering onto a 120 DPI bitmap then pixelsPerDip is 1.25. + Optional transform applied to the glyphs and their positions. This transform is applied after the scaling specified the emSize and pixelsPerDip. + A value that specifies the rendering mode, which must be one of the raster rendering modes (that is, not default and not outline). + Specifies the measuring mode to use with glyphs. + The horizontal position (X-coordinate) of the baseline origin, in DIPs. + Vertical position (Y-coordinate) of the baseline origin, in DIPs. + + The glyph run analysis object contains the results of analyzing the glyph run, including the positions of all the glyphs and references to all of the rasterized glyphs in the font cache. + + HRESULT IDWriteFactory::CreateGlyphRunAnalysis([In] const DWRITE_GLYPH_RUN* glyphRun,[None] float pixelsPerDip,[In, Optional] const DWRITE_MATRIX* transform,[None] DWRITE_RENDERING_MODE renderingMode,[None] DWRITE_MEASURING_MODE measuringMode,[None] float baselineOriginX,[None] float baselineOriginY,[Out] IDWriteGlyphRunAnalysis** glyphRunAnalysis) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Gets the bounding rectangle of the physical pixels affected by the glyph run. + + Specifies the type of texture requested. If a bi-level texture is requested, the bounding rectangle includes only bi-level glyphs. Otherwise, the bounding rectangle includes only antialiased glyphs. + When this method returns, contains the bounding rectangle of the physical pixels affected by the glyph run, or an empty rectangle if there are no glyphs of the specified texture type. + HRESULT IDWriteGlyphRunAnalysis::GetAlphaTextureBounds([None] DWRITE_TEXTURE_TYPE textureType,[Out] RECT* textureBounds) + + + + Creates an alpha texture of the specified type for glyphs within a specified bounding rectangle. + + A value that specifies the type of texture requested. This can be {{DWRITE_TEXTURE_BILEVEL_1x1}} or DWRITE_TEXTURE_CLEARTYPE_3x1. If a bi-level texture is requested, the texture contains only bi-level glyphs. Otherwise, the texture contains only antialiased glyphs. + The bounding rectangle of the texture, which can be different than the bounding rectangle returned by {{GetAlphaTextureBounds}}. + When this method returns, contains the array of alpha values from the texture. The buffer allocated for this array must be at least the size of bufferSize. + The size of the alphaValues array, in bytes. The minimum size depends on the dimensions of the rectangle and the type of texture requested. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteGlyphRunAnalysis::CreateAlphaTexture([None] DWRITE_TEXTURE_TYPE textureType,[In] const RECT* textureBounds,[Out, Buffer] byte* alphaValues,[None] int bufferSize) + + + + Gets alpha blending properties required for ClearType blending. + + An object that specifies the ClearType level and enhanced contrast, gamma, pixel geometry, and rendering mode. In most cases, the values returned by the output parameters of this method are based on the properties of this object, unless a GDI-compatible rendering mode was specified. + When this method returns, contains the gamma value to use for gamma correction. + When this method returns, contains the enhanced contrast value to be used for blending. + When this method returns, contains the ClearType level used in the alpha blending. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteGlyphRunAnalysis::GetAlphaBlendParams([None] IDWriteRenderingParams* renderingParams,[Out] float* blendGamma,[Out] float* blendEnhancedContrast,[Out] float* blendClearTypeLevel) + + + + Contains additional properties related to those in DWRITE_GLYPH_RUN. + + DWRITE_GLYPH_RUN_DESCRIPTION + + + + An array of characters containing the locale name associated with this run. + + const wchar_t* localeName + + + + An array of characters containing the text associated with the glyphs. + + const wchar_t* string + + + + The number of characters in UTF16 code-units. Note that this may be different than the number of glyphs. + + int stringLength + + + + An array of indices to the glyph indices array, of the first glyphs of all the glyph clusters of the glyphs to render. + + const short* clusterMap + + + + Corresponding text position in the string this glyph run came from. This is relative to the beginning of the string represented by the IDWriteTextLayout object. + + int textPosition + + + + A Item. + + + + + A glyph index + + + + + A glyph advance + + + + + A glyph offset + + + + + Internal InlineObject Callback + + + + + Initializes a new instance of the class. + + The callback. + + + + Gets or sets the callback. + + The callback. + + + HRESULT IDWriteInlineObject::Draw([None] void* clientDrawingContext,[None] IDWriteTextRenderer* renderer,[None] float originX,[None] float originY,[None] BOOL isSideways,[None] BOOL isRightToLeft,[None] IUnknown* clientDrawingEffect) + + + HRESULT IDWriteInlineObject::GetMetrics([Out] DWRITE_INLINE_OBJECT_METRICS* metrics) + + + HRESULT IDWriteInlineObject::GetOverhangMetrics([Out] DWRITE_OVERHANG_METRICS* overhangs) + + + HRESULT IDWriteInlineObject::GetBreakConditions([Out] DWRITE_BREAK_CONDITION* breakConditionBefore,[Out] DWRITE_BREAK_CONDITION* breakConditionAfter) + + + + Line breakpoint characteristics of a character. + + DWRITE_LINE_BREAKPOINT + + + + Indicates a breaking condition before the character. + + byte breakConditionBefore + + + + Indicates a breaking condition after the character. + + byte breakConditionAfter + + + + Indicates a breaking condition before the character. + + byte breakConditionBefore + + + + Indicates a breaking condition after the character. + + byte breakConditionAfter + + + + Indicates that the character is some form of whitespace, which may be meaningful for justification. + + byte isWhitespace + + + + Indicates that the character is a soft hyphen, often used to indicate hyphenation points inside words. + + byte isSoftHyphen + + + + Reserved for future use. + + byte padding + + + + Represents a collection of strings indexed by locale name. + + IDWriteLocalizedStrings + + + + Get the locale name from the language. + + Zero-based index of the locale name to be retrieved. + The locale name from the language + HRESULT IDWriteLocalizedStrings::GetLocaleName([None] int index,[Out, Buffer] wchar_t* localeName,[None] int size) + + + + Get the string from the language/string pair. + + Zero-based index of the string from the language/string pair to be retrieved. + The locale name from the language + HRESULT IDWriteLocalizedStrings::GetLocaleName([None] int index,[Out, Buffer] wchar_t* localeName,[None] int size) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Gets the number of language/string pairs. + + The number of language/string pairs. + int IDWriteLocalizedStrings::GetCount() + + + + Gets the zero-based index of the locale name/string pair with the specified locale name. + + + Note that if the locale name does not exist, the return value is a success and the exists parameter is FALSE. If you are getting the font family name for a font and the specified locale name does not exist, one option is to set the index to 0 as shown below. There is always at least one locale for a font family. + UINT32 index = 0; + BOOL exists = false; wchar_t localeName[LOCALE_NAME_MAX_LENGTH]; if (SUCCEEDED(hr)) + { // Get the default locale for this user. int defaultLocaleSuccess = GetUserDefaultLocaleName(localeName, LOCALE_NAME_MAX_LENGTH); // If the default locale is returned, find that locale name, otherwise use "en-us". if (defaultLocaleSuccess) { hr = pFamilyNames->FindLocaleName(localeName, &index, &exists); } if (SUCCEEDED(hr) && !exists) // if the above find did not find a match, retry with US English { hr = pFamilyNames->FindLocaleName(L"en-us", &index, &exists); } + } // If the specified locale doesn't exist, select the first on the list. + if (!exists) index = 0; + + + A null-terminated array of characters containing the locale name to look for. + The zero-based index of the locale name/string pair. This method initializes index to UINT_MAX. + When this method returns, contains TRUE if the locale name exists; otherwise, FALSE. This method initializes exists to FALSE. + HRESULT IDWriteLocalizedStrings::FindLocaleName([In] const wchar_t* localeName,[Out] int* index,[Out] BOOL* exists) + + + + Gets the length in characters (not including the null terminator) of the locale name with the specified index. + + Zero-based index of the locale name to be retrieved. + When this method returns, contains the length in characters of the locale name, not including the null terminator. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteLocalizedStrings::GetLocaleNameLength([None] int index,[Out] int* length) + + + + Copies the locale name with the specified index to the specified array. + + Zero-based index of the locale name to be retrieved. + When this method returns, contains a character array, which is null-terminated, that receives the locale name from the language/string pair. The buffer allocated for this array must be at least the size of size, in element count. + The size of the array in characters. The size must include space for the terminating null character. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteLocalizedStrings::GetLocaleName([None] int index,[Out, Buffer] wchar_t* localeName,[None] int size) + + + + Gets the length in characters (not including the null terminator) of the string with the specified index. + + + Use GetStringLength to get the string length before calling the method, as shown in the following code. + UINT32 length = 0; // Get the string length. + if (SUCCEEDED(hr)) + { hr = pFamilyNames->GetStringLength(index, &length); + } // Allocate a string big enough to hold the name. + wchar_t* name = new (std::nothrow) wchar_t[length+1]; + if (name == NULL) + { hr = E_OUTOFMEMORY; + } // Get the family name. + if (SUCCEEDED(hr)) + { hr = pFamilyNames->GetString(index, name, length+1); + } + + + A zero-based index of the language/string pair. + The length in characters of the string, not including the null terminator, from the language/string pair. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteLocalizedStrings::GetStringLength([None] int index,[Out] int* length) + + + + Copies the string with the specified index to the specified array. + + + The string returned must be allocated by the caller. You can get the size of the string by using the {{GetStringLength}} method prior to calling GetString, as shown in the following example. + UINT32 length = 0; // Get the string length. + if (SUCCEEDED(hr)) + { hr = pFamilyNames->GetStringLength(index, &length); + } // Allocate a string big enough to hold the name. + wchar_t* name = new (std::nothrow) wchar_t[length+1]; + if (name == NULL) + { hr = E_OUTOFMEMORY; + } // Get the family name. + if (SUCCEEDED(hr)) + { hr = pFamilyNames->GetString(index, name, length+1); + } + + + The zero-based index of the language/string pair to be examined. + The null terminated array of characters that receives the string from the language/string pair. The buffer allocated for this array should be at least the size of size. {{GetStringLength}} can be used to get the size of the array before using this method. + The size of the array in characters. The size must include space for the terminating null character. {{GetStringLength}} can be used to get the size of the array before using this method. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteLocalizedStrings::GetString([None] int index,[Out, Buffer] wchar_t* stringBuffer,[None] int size) + + + + Gets the number of language/string pairs. + + int IDWriteLocalizedStrings::GetCount() + + + + Holds the appropriate digits and numeric punctuation for a specified locale. + + IDWriteNumberSubstitution + + + + Creates a number substitution object using a locale name, substitution method, and an indicator whether to ignore user overrides (use NLS defaults for the given culture instead). + + A reference to a DirectWrite factory + A value that specifies how to apply number substitution on digits and related punctuation. + The name of the locale to be used in the numberSubstitution object. + A Boolean flag that indicates whether to ignore user overrides. + HRESULT IDWriteFactory::CreateNumberSubstitution([In] DWRITE_NUMBER_SUBSTITUTION_METHOD substitutionMethod,[In] const wchar_t* localeName,[In] BOOL ignoreUserOverride,[Out] IDWriteNumberSubstitution** numberSubstitution) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Defines the pixel snapping properties such as pixels per DIP(device-independent pixel) and the current transform matrix of a text renderer. + + IDWritePixelSnapping + + + + Determines whether pixel snapping is disabled. The recommended default is FALSE, + unless doing animation that requires subpixel vertical placement. + + The context passed to IDWriteTextLayout::Draw. + Receives TRUE if pixel snapping is disabled or FALSE if it not. + HRESULT IsPixelSnappingDisabled([None] void* clientDrawingContext,[Out] BOOL* isDisabled) + + + + Gets a transform that maps abstract coordinates to DIPs. + + The drawing context passed to . + a structure which has transform information for pixel snapping. + HRESULT GetCurrentTransform([None] void* clientDrawingContext,[Out] DWRITE_MATRIX* transform) + + + + Gets the number of physical pixels per DIP. + + + Because a DIP (device-independent pixel) is 1/96 inch, the pixelsPerDip value is the number of logical pixels per inch divided by 96. + + The drawing context passed to . + the number of physical pixels per DIP + HRESULT GetPixelsPerDip([None] void* clientDrawingContext,[Out] FLOAT* pixelsPerDip) + + + + Internal TessellationSink Callback + + + + + Gets or sets the callback. + + The callback. + + + + Determines whether pixel snapping is disabled. The recommended default is FALSE, + unless doing animation that requires subpixel vertical placement. + + This pointer + The context passed to IDWriteTextLayout::Draw. + Output disabled + Receives TRUE if pixel snapping is disabled or FALSE if it not. + HRESULT IsPixelSnappingDisabled([None] void* clientDrawingContext,[Out] BOOL* isDisabled) + + + + Gets a transform that maps abstract coordinates to DIPs. + + This pointer + The drawing context passed to . + Matrix transform + a structure which has transform information for pixel snapping. + HRESULT GetCurrentTransform([None] void* clientDrawingContext,[Out] DWRITE_MATRIX* transform) + + + + Gets the number of physical pixels per DIP. + + + Because a DIP (device-independent pixel) is 1/96 inch, the pixelsPerDip value is the number of logical pixels per inch divided by 96. + + This pointer + The drawing context passed to . + Dip + the number of physical pixels per DIP + HRESULT GetPixelsPerDip([None] void* clientDrawingContext,[Out] FLOAT* pixelsPerDip) + + + + Represents text rendering settings such as ClearType level, enhanced contrast, and gamma correction for glyph rasterization and filtering. + + IDWriteRenderingParams + + + + Creates a rendering parameters object with default settings for the primary monitor. Different monitors may have different rendering parameters, for more information see the {{How to Add Support for Multiple Monitors}} topic. + + A reference to a DirectWrite factory + HRESULT IDWriteFactory::CreateRenderingParams([Out] IDWriteRenderingParams** renderingParams) + + + + Creates a rendering parameters object with default settings for the specified monitor. In most cases, this is the preferred way to create a rendering parameters object. + + A reference to a DirectWrite factory + A handle for the specified monitor. + HRESULT IDWriteFactory::CreateMonitorRenderingParams([None] void* monitor,[Out] IDWriteRenderingParams** renderingParams) + + + + Creates a rendering parameters object with the specified properties. + + A reference to a DirectWrite factory + The gamma level to be set for the new rendering parameters object. + The enhanced contrast level to be set for the new rendering parameters object. + The ClearType level to be set for the new rendering parameters object. + Represents the internal structure of a device pixel (that is, the physical arrangement of red, green, and blue color components) that is assumed for purposes of rendering text. + A value that represents the method (for example, ClearType natural quality) for rendering glyphs. + HRESULT IDWriteFactory::CreateCustomRenderingParams([None] float gamma,[None] float enhancedContrast,[None] float clearTypeLevel,[None] DWRITE_PIXEL_GEOMETRY pixelGeometry,[None] DWRITE_RENDERING_MODE renderingMode,[Out] IDWriteRenderingParams** renderingParams) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Gets the gamma value used for gamma correction. Valid values must be greater than zero and cannot exceed 256. + + + The gamma value is used for gamma correction, which compensates for the non-linear luminosity response of most monitors. + + Returns the gamma value used for gamma correction. Valid values must be greater than zero and cannot exceed 256. + float IDWriteRenderingParams::GetGamma() + + + + Gets the enhanced contrast property of the rendering parameters object. Valid values are greater than or equal to zero. + + + Enhanced contrast is the amount to increase the darkness of text, and typically ranges from 0 to 1. Zero means no contrast enhancement. + + Returns the amount of contrast enhancement. Valid values are greater than or equal to zero. + float IDWriteRenderingParams::GetEnhancedContrast() + + + + Gets the ClearType level of the rendering parameters object. + + + The ClearType level represents the amount of ClearType ? that is, the degree to which the red, green, and blue subpixels of each pixel are treated differently. Valid values range from zero (meaning no ClearType, which is equivalent to grayscale anti-aliasing) to one (meaning full ClearType) + + The ClearType level of the rendering parameters object. + float IDWriteRenderingParams::GetClearTypeLevel() + + + + Gets the pixel geometry of the rendering parameters object. + + A value that indicates the type of pixel geometry used in the rendering parameters object. + DWRITE_PIXEL_GEOMETRY IDWriteRenderingParams::GetPixelGeometry() + + + + Gets the rendering mode of the rendering parameters object. + + + By default, the rendering mode is initialized to DWRITE_RENDERING_MODE_DEFAULT, which means the rendering mode is determined automatically based on the font and size. To determine the recommended rendering mode to use for a given font and size and rendering parameters object, use the method. + + A value that indicates the rendering mode of the rendering parameters object. + DWRITE_RENDERING_MODE IDWriteRenderingParams::GetRenderingMode() + + + + Gets the gamma value used for gamma correction. Valid values must be greater than zero and cannot exceed 256. + + + The gamma value is used for gamma correction, which compensates for the non-linear luminosity response of most monitors. + + float IDWriteRenderingParams::GetGamma() + + + + Gets the enhanced contrast property of the rendering parameters object. Valid values are greater than or equal to zero. + + + Enhanced contrast is the amount to increase the darkness of text, and typically ranges from 0 to 1. Zero means no contrast enhancement. + + float IDWriteRenderingParams::GetEnhancedContrast() + + + + Gets the ClearType level of the rendering parameters object. + + + The ClearType level represents the amount of ClearType ? that is, the degree to which the red, green, and blue subpixels of each pixel are treated differently. Valid values range from zero (meaning no ClearType, which is equivalent to grayscale anti-aliasing) to one (meaning full ClearType) + + float IDWriteRenderingParams::GetClearTypeLevel() + + + + Gets the pixel geometry of the rendering parameters object. + + DWRITE_PIXEL_GEOMETRY IDWriteRenderingParams::GetPixelGeometry() + + + + Gets the rendering mode of the rendering parameters object. + + + By default, the rendering mode is initialized to DWRITE_RENDERING_MODE_DEFAULT, which means the rendering mode is determined automatically based on the font and size. To determine the recommended rendering mode to use for a given font and size and rendering parameters object, use the method. + + DWRITE_RENDERING_MODE IDWriteRenderingParams::GetRenderingMode() + + + + Defines glyph characteristic information that an application needs to implement justification. + + + + + Justification cannot be applied at the glyph. + + + + + The glyph represents a blank in an Arabic run. + + + + + An inter-character justification point follows the glyph. + + + + + The glyph represents a blank outside an Arabic run. + + + + + Normal middle-of-word glyph that connects to the right (begin). + + + + + Kashida (U+0640) in the middle of the word. + + + + + Final form of an alef-like (U+0627, U+0625, U+0623, U+0622). + + + + + Final form of Ha (U+0647). + + + + + Final form of Ra (U+0631). + + + + + Final form of Ba (U+0628). + + + + + Ligature of alike (U+0628,U+0631). + + + + + Highest priority: initial shape of Seen class (U+0633). + + + + + Highest priority: medial shape of Seen class (U+0633). + + + + + Contains shaping output properties for an output glyph. + + DWRITE_SHAPING_GLYPH_PROPERTIES + + + + Indicates that the glyph has justification applied. + + short justification + + + + Indicates that the glyph has justification applied. + + short justification + + + + Indicates that the glyph is the start of a cluster. + + short isClusterStart + + + + Indicates that the glyph is a diacritic mark. + + short isDiacritic + + + + Indicates that the glyph is a word boundary with no visible space. + + short isZeroWidthSpace + + + + Reserved for future use. + + short reserved + + + + This interface is implemented by the text analyzer's client to receive the output of a given text analysis. + + IDWriteTextAnalysisSink + + + + Reports script analysis for the specified text range. + + The starting position from which to report. + The number of UTF16 units of the reported range. + A reference to a structure that contains a zero-based index representation of a writing system script and a value indicating whether additional shaping of text is required. + A successful code or error code to stop analysis. + HRESULT IDWriteTextAnalysisSink::SetScriptAnalysis([None] int textPosition,[None] int textLength,[In] const DWRITE_SCRIPT_ANALYSIS* scriptAnalysis) + + + + Sets line-break opportunities for each character, starting from the specified position. + + The starting text position from which to report. + The number of UTF16 units of the reported range. + A reference to a structure that contains breaking conditions set for each character from the starting position to the end of the specified range. + A successful code or error code to stop analysis. + HRESULT IDWriteTextAnalysisSink::SetLineBreakpoints([None] int textPosition,[None] int textLength,[In, Buffer] const DWRITE_LINE_BREAKPOINT* lineBreakpoints) + + + + Sets a bidirectional level on the range, which is called once per run change (either explicit or resolved implicit). + + The starting position from which to report. + The number of UTF16 units of the reported range. + The explicit level from the paragraph reading direction and any embedded control codes RLE/RLO/LRE/LRO/PDF, which is determined before any additional rules. + The final implicit level considering the explicit level and characters' natural directionality, after all Bidi rules have been applied. + A successful code or error code to stop analysis. + HRESULT IDWriteTextAnalysisSink::SetBidiLevel([None] int textPosition,[None] int textLength,[None] int explicitLevel,[None] int resolvedLevel) + + + + Sets the number substitution on the text range affected by the text analysis. + + The starting position from which to report. + The number of UTF16 units of the reported range. + An object that holds the appropriate digits and numeric punctuation for a given locale. Use to create this object. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextAnalysisSink::SetNumberSubstitution([None] int textPosition,[None] int textLength,[None] IDWriteNumberSubstitution* numberSubstitution) + + + + Internal TextAnalysisSink Callback + + + + + Initializes a new instance of the class. + + The callback. + + + + Gets or sets the callback. + + The callback. + + + HRESULT IDWriteTextAnalysisSink::SetScriptAnalysis([None] int textPosition,[None] int textLength,[In] const DWRITE_SCRIPT_ANALYSIS* scriptAnalysis) + + + HRESULT IDWriteTextAnalysisSink::SetLineBreakpoints([None] int textPosition,[None] int textLength,[In, Buffer] const DWRITE_LINE_BREAKPOINT* lineBreakpoints) + + + HRESULT IDWriteTextAnalysisSink::SetBidiLevel([None] int textPosition,[None] int textLength,[None] int explicitLevel,[None] int resolvedLevel) + + + HRESULT IDWriteTextAnalysisSink::SetNumberSubstitution([None] int textPosition,[None] int textLength,[None] IDWriteNumberSubstitution* numberSubstitution) + + + + Implemented by the text analyzer's client to provide text to the analyzer. It allows the separation between the logical view of text as a continuous stream of characters identifiable by unique text positions, and the actual memory layout of potentially discrete blocks of text in the client's backing store. + + IDWriteTextAnalysisSource + + + + Gets a block of text starting at the specified text position. + + + Returning NULL indicates the end of text, which is the position after the last character. This function is called iteratively for each consecutive block, tying together several fragmented blocks in the backing store into a virtual contiguous string. Although applications can implement sparse textual content that maps only part of the backing store, the application must map any text that is in the range passed to any analysis functions. + + The first position of the piece to obtain. All positions are in UTF16 code units, not whole characters, which matters when supplementary characters are used. + a block of text + HRESULT IDWriteTextAnalysisSource::GetTextAtPosition([None] int textPosition,[Out] const wchar_t** textString,[Out] int* textLength) + + + + Gets a block of text immediately preceding the specified position. + + + NULL indicates no chunk available at the specified position, either because textPosition equals 0, textPosition is greater than the entire text content length, or the queried position is not mapped into the application's backing store. Although applications can implement sparse textual content that maps only part of the backing store, the application must map any text that is in the range passed to any analysis functions. + + The position immediately after the last position of the block of text to obtain. + text immediately preceding the specified position + HRESULT IDWriteTextAnalysisSource::GetTextBeforePosition([None] int textPosition,[Out] const wchar_t** textString,[Out] int* textLength) + + + + Gets the locale name on the range affected by the text analysis. + + + The localeName reference must remain valid until the next call or until the analysis returns. + + The text position to examine. + the locale name on the range affected by the text analysis + HRESULT IDWriteTextAnalysisSource::GetLocaleName([None] int textPosition,[Out] int* textLength,[Out] const wchar_t** localeName) + + + + Gets the number substitution from the text range affected by the text analysis. + + + Any implementation should return the number substitution with an incremented reference count, and the analysis will release when finished with it (either before the next call or before it returns). However, the sink callback may hold onto it after that. + + The starting position from which to report. + Contains the length of the text, in characters, remaining in the text range up to the next differing number substitution. + the number substitution from the text range affected by the text analysis. + HRESULT IDWriteTextAnalysisSource::GetNumberSubstitution([None] int textPosition,[Out] int* textLength,[Out] IDWriteNumberSubstitution** numberSubstitution) + + + + Gets the paragraph reading direction. + + The reading direction of the current paragraph. + DWRITE_READING_DIRECTION IDWriteTextAnalysisSource::GetParagraphReadingDirection() + + + + Internal TextAnalysisSource Callback + + + + + Initializes a new instance of the class. + + The callback. + + + + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + + + + + Gets or sets the callback. + + The callback. + + + HRESULT IDWriteTextAnalysisSource::GetTextAtPosition([None] int textPosition,[Out] const wchar_t** textString,[Out] int* textLength) + + + HRESULT IDWriteTextAnalysisSource::GetTextBeforePosition([None] int textPosition,[Out] const wchar_t** textString,[Out] int* textLength) + + + DWRITE_READING_DIRECTION IDWriteTextAnalysisSource::GetParagraphReadingDirection() + + + HRESULT IDWriteTextAnalysisSource::GetLocaleName([None] int textPosition,[Out] int* textLength,[Out] const wchar_t** localeName) + + + HRESULT IDWriteTextAnalysisSource::GetNumberSubstitution([None] int textPosition,[Out] int* textLength,[Out] IDWriteNumberSubstitution** numberSubstitution) + + + + Analyzes various text properties for complex script processing such as bidirectional (bidi) support for languages like Arabic, determination of line break opportunities, glyph placement, and number substitution. + + IDWriteTextAnalyzer + + + + Returns an interface for performing text analysis. + + A reference to a DirectWrite factory + HRESULT IDWriteFactory::CreateTextAnalyzer([Out] IDWriteTextAnalyzer** textAnalyzer) + + + + Analyzes a text range for script boundaries, reading text attributes from the source and reporting the Unicode script ID to the sink callback {{SetScript}}. + + A reference to the source object to analyze. + The starting text position within the source object. + The text length to analyze. + A reference to the sink callback object that receives the text analysis. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextAnalyzer::AnalyzeScript([None] IDWriteTextAnalysisSource* analysisSource,[None] int textPosition,[None] int textLength,[None] IDWriteTextAnalysisSink* analysisSink) + + + + Analyzes a text range for script directionality, reading attributes from the source and reporting levels to the sink callback {{SetBidiLevel}}. + + + While the function can handle multiple paragraphs, the text range should not arbitrarily split the middle of paragraphs. Otherwise, the returned levels may be wrong, because the Bidi algorithm is meant to apply to the paragraph as a whole. + + A reference to a source object to analyze. + The starting text position within the source object. + The text length to analyze. + A reference to the sink callback object that receives the text analysis. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextAnalyzer::AnalyzeBidi([None] IDWriteTextAnalysisSource* analysisSource,[None] int textPosition,[None] int textLength,[None] IDWriteTextAnalysisSink* analysisSink) + + + + Analyzes a text range for spans where number substitution is applicable, reading attributes from the source and reporting substitutable ranges to the sink callback {{SetNumberSubstitution}}. + + + Although the function can handle multiple ranges of differing number substitutions, the text ranges should not arbitrarily split the middle of numbers. Otherwise, it will treat the numbers separately and will not translate any intervening punctuation. + + The source object to analyze. + The starting position within the source object. + The length to analyze. + A reference to the sink callback object that receives the text analysis. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextAnalyzer::AnalyzeNumberSubstitution([None] IDWriteTextAnalysisSource* analysisSource,[None] int textPosition,[None] int textLength,[None] IDWriteTextAnalysisSink* analysisSink) + + + + Analyzes a text range for potential breakpoint opportunities, reading attributes from the source and reporting breakpoint opportunities to the sink callback {{SetLineBreakpoints}}. + + + Although the function can handle multiple paragraphs, the text range should not arbitrarily split the middle of paragraphs, unless the specified text span is considered a whole unit. Otherwise, the returned properties for the first and last characters will inappropriately allow breaks. + + A reference to the source object to analyze. + The starting text position within the source object. + The text length to analyze. + A reference to the sink callback object that receives the text analysis. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextAnalyzer::AnalyzeLineBreakpoints([None] IDWriteTextAnalysisSource* analysisSource,[None] int textPosition,[None] int textLength,[None] IDWriteTextAnalysisSink* analysisSink) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Analyzes a text range for script boundaries, reading text attributes from the source and reporting the Unicode script ID to the sink callback {{SetScript}}. + + A reference to the source object to analyze. + The starting text position within the source object. + The text length to analyze. + A reference to the sink callback object that receives the text analysis. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextAnalyzer::AnalyzeScript([None] IDWriteTextAnalysisSource* analysisSource,[None] int textPosition,[None] int textLength,[None] IDWriteTextAnalysisSink* analysisSink) + + + + Analyzes a text range for script directionality, reading attributes from the source and reporting levels to the sink callback {{SetBidiLevel}}. + + + While the function can handle multiple paragraphs, the text range should not arbitrarily split the middle of paragraphs. Otherwise, the returned levels may be wrong, because the Bidi algorithm is meant to apply to the paragraph as a whole. + + A reference to a source object to analyze. + The starting text position within the source object. + The text length to analyze. + A reference to the sink callback object that receives the text analysis. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextAnalyzer::AnalyzeBidi([None] IDWriteTextAnalysisSource* analysisSource,[None] int textPosition,[None] int textLength,[None] IDWriteTextAnalysisSink* analysisSink) + + + + Analyzes a text range for spans where number substitution is applicable, reading attributes from the source and reporting substitutable ranges to the sink callback {{SetNumberSubstitution}}. + + + Although the function can handle multiple ranges of differing number substitutions, the text ranges should not arbitrarily split the middle of numbers. Otherwise, it will treat the numbers separately and will not translate any intervening punctuation. + + The source object to analyze. + The starting position within the source object. + The length to analyze. + A reference to the sink callback object that receives the text analysis. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextAnalyzer::AnalyzeNumberSubstitution([None] IDWriteTextAnalysisSource* analysisSource,[None] int textPosition,[None] int textLength,[None] IDWriteTextAnalysisSink* analysisSink) + + + + Analyzes a text range for potential breakpoint opportunities, reading attributes from the source and reporting breakpoint opportunities to the sink callback {{SetLineBreakpoints}}. + + + Although the function can handle multiple paragraphs, the text range should not arbitrarily split the middle of paragraphs, unless the specified text span is considered a whole unit. Otherwise, the returned properties for the first and last characters will inappropriately allow breaks. + + A reference to the source object to analyze. + The starting text position within the source object. + The text length to analyze. + A reference to the sink callback object that receives the text analysis. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextAnalyzer::AnalyzeLineBreakpoints([None] IDWriteTextAnalysisSource* analysisSource,[None] int textPosition,[None] int textLength,[None] IDWriteTextAnalysisSink* analysisSink) + + + + Parses the input text string and maps it to the set of glyphs and associated glyph data according to the font and the writing system's rendering rules. + + + Note that the mapping from characters to glyphs is, in general, many-to-many. The recommended estimate for the per-glyph output buffers is (3 * textLength / 2 + 16). This is not guaranteed to be sufficient. The value of the actualGlyphCount parameter is only valid if the call succeeds. In the event that maxGlyphCount is not big enough, HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) will be returned. The application should allocate a larger buffer and try again. + + An array of characters to convert to glyphs. + The length of textString. + The font face that is the source of the output glyphs. + A Boolean flag set to true if the text is intended to be drawn vertically. + A Boolean flag set to TRUE for right-to-left text. + A reference to a Script analysis result from an {{AnalyzeScript}} call. + The locale to use when selecting glyphs. For example the same character may map to different glyphs for ja-jp versus zh-chs. If this is NULL, then the default mapping based on the script is used. + A reference to an optional number substitution which selects the appropriate glyphs for digits and related numeric characters, depending on the results obtained from AnalyzeNumberSubstitution. Passing NULL indicates that no substitution is needed and that the digits should receive nominal glyphs. + An array of references to the sets of typographic features to use in each feature range. + The length of each feature range, in characters. The sum of all lengths should be equal to textLength. + The number of feature ranges. + The maximum number of glyphs that can be returned. + When this method returns, contains the mapping from character ranges to glyph ranges. + When this method returns, contains a reference to an array of structures that contains shaping properties for each character. + The output glyph indices. + When this method returns, contains a reference to an array of structures that contain shaping properties for each output glyph. + When this method returns, contains the actual number of glyphs returned if the call succeeds. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextAnalyzer::GetGlyphs([In, Buffer] const wchar_t* textString,[None] int textLength,[None] IDWriteFontFace* fontFace,[None] BOOL isSideways,[None] BOOL isRightToLeft,[In] const DWRITE_SCRIPT_ANALYSIS* scriptAnalysis,[In, Optional] const wchar_t* localeName,[None] IDWriteNumberSubstitution* numberSubstitution,[In, Buffer, Optional] const DWRITE_TYPOGRAPHIC_FEATURES** features,[In, Buffer, Optional] const int* featureRangeLengths,[None] int featureRanges,[None] int maxGlyphCount,[Out, Buffer] short* clusterMap,[Out, Buffer] DWRITE_SHAPING_TEXT_PROPERTIES* textProps,[Out, Buffer] short* glyphIndices,[Out, Buffer] DWRITE_SHAPING_GLYPH_PROPERTIES* glyphProps,[Out] int* actualGlyphCount) + + + + Places glyphs output from the {{GetGlyphs}} method according to the font and the writing system's rendering rules. + + An array of characters containing the original string from which the glyphs came. + A reference to the mapping from character ranges to glyph ranges. This is returned by {{GetGlyphs}}. + A reference to an array of structures that contains shaping properties for each character. This structure is returned by {{GetGlyphs}}. + The text length of textString. + An array of glyph indices returned by {{GetGlyphs}}. + A reference to an array of structures that contain shaping properties for each glyph returned by {{GetGlyphs}}. + The number of glyphs returned from {{GetGlyphs}}. + A reference to the font face that is the source for the output glyphs. + The logical font size in DIPs. + A Boolean flag set to TRUE if the text is intended to be drawn vertically. + A Boolean flag set to TRUE for right-to-left text. + A reference to a Script analysis result from an{{AnalyzeScript}} call. + An array of characters containing the locale to use when selecting glyphs. For example, the same character may map to different glyphs for ja-jp versus zh-chs. If this is NULL, then the default mapping based on the script is used. + An array of references to the sets of typographic features to use in each feature range. + The length of each feature range, in characters. The sum of all lengths should be equal to textLength. + The number of feature ranges. + When this method returns, contains the advance width of each glyph. + When this method returns, contains the offset of the origin of each glyph. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextAnalyzer::GetGlyphPlacements([In, Buffer] const wchar_t* textString,[In, Buffer] const short* clusterMap,[In, Buffer] DWRITE_SHAPING_TEXT_PROPERTIES* textProps,[None] int textLength,[In, Buffer] const short* glyphIndices,[In, Buffer] const DWRITE_SHAPING_GLYPH_PROPERTIES* glyphProps,[None] int glyphCount,[None] IDWriteFontFace* fontFace,[None] float fontEmSize,[None] BOOL isSideways,[None] BOOL isRightToLeft,[In] const DWRITE_SCRIPT_ANALYSIS* scriptAnalysis,[In, Optional] const wchar_t* localeName,[In, Buffer, Optional] const DWRITE_TYPOGRAPHIC_FEATURES** features,[In, Buffer, Optional] const int* featureRangeLengths,[None] int featureRanges,[Out, Buffer] float* glyphAdvances,[Out, Buffer] DWRITE_GLYPH_OFFSET* glyphOffsets) + + + + Place glyphs output from the GetGlyphs method according to the font and the writing system's rendering rules. + + An array of characters containing the original string from which the glyphs came. + A reference to the mapping from character ranges to glyph ranges. This is returned by {{GetGlyphs}}. + A reference to an array of structures that contains shaping properties for each character. This structure is returned by {{GetGlyphs}}. + The text length of textString. + An array of glyph indices returned by {{GetGlyphs}}. + A reference to an array of structures that contain shaping properties for each glyph returned by {{GetGlyphs}}. + The number of glyphs returned from {{GetGlyphs}}. + A reference to the font face that is the source for the output glyphs. + The logical font size in DIPs. + The number of physical pixels per DIP. + An optional transform applied to the glyphs and their positions. This transform is applied after the scaling specified by the font size and pixelsPerDip. + When set to FALSE, the metrics are the same as the metrics of GDI aliased text. When set to TRUE, the metrics are the same as the metrics of text measured by GDI using a font created with CLEARTYPE_NATURAL_QUALITY. + A Boolean flag set to TRUE if the text is intended to be drawn vertically. + A Boolean flag set to TRUE for right-to-left text. + A reference to a Script analysis result from an{{AnalyzeScript}} call. + An array of characters containing the locale to use when selecting glyphs. For example, the same character may map to different glyphs for ja-jp versus zh-chs. If this is NULL, then the default mapping based on the script is used. + An array of references to the sets of typographic features to use in each feature range. + The length of each feature range, in characters. The sum of all lengths should be equal to textLength. + The number of feature ranges. + When this method returns, contains the advance width of each glyph. + When this method returns, contains the offset of the origin of each glyph. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextAnalyzer::GetGdiCompatibleGlyphPlacements([In, Buffer] const wchar_t* textString,[In, Buffer] const short* clusterMap,[In, Buffer] DWRITE_SHAPING_TEXT_PROPERTIES* textProps,[None] int textLength,[In, Buffer] const short* glyphIndices,[In, Buffer] const DWRITE_SHAPING_GLYPH_PROPERTIES* glyphProps,[None] int glyphCount,[None] IDWriteFontFace* fontFace,[None] float fontEmSize,[None] float pixelsPerDip,[In, Optional] const DWRITE_MATRIX* transform,[None] BOOL useGdiNatural,[None] BOOL isSideways,[None] BOOL isRightToLeft,[In] const DWRITE_SCRIPT_ANALYSIS* scriptAnalysis,[In, Optional] const wchar_t* localeName,[In, Buffer, Optional] const DWRITE_TYPOGRAPHIC_FEATURES** features,[In, Buffer, Optional] const int* featureRangeLengths,[None] int featureRanges,[Out, Buffer] float* glyphAdvances,[Out, Buffer] DWRITE_GLYPH_OFFSET* glyphOffsets) + + + + The IDWriteTextFormat interface describes the font and paragraph properties used to format text, and it describes locale information. + + IDWriteTextFormat + + + + Creates a text format object used for text layout with normal weight, style and stretch. + + an instance of + An array of characters that contains the name of the font family + The logical size of the font in DIP ("device-independent pixel") units. A DIP equals 1/96 inch. + HRESULT CreateTextFormat([In] const wchar* fontFamilyName,[None] IDWriteFontCollection* fontCollection,[None] DWRITE_FONT_WEIGHT fontWeight,[None] DWRITE_FONT_STYLE fontStyle,[None] DWRITE_FONT_STRETCH fontStretch,[None] FLOAT fontSize,[In] const wchar* localeName,[Out] IDWriteTextFormat** textFormat) + + + + Creates a text format object used for text layout with normal stretch. + + an instance of + An array of characters that contains the name of the font family + A value that indicates the font weight for the text object created by this method. + A value that indicates the font style for the text object created by this method. + The logical size of the font in DIP ("device-independent pixel") units. A DIP equals 1/96 inch. + HRESULT CreateTextFormat([In] const wchar* fontFamilyName,[None] IDWriteFontCollection* fontCollection,[None] DWRITE_FONT_WEIGHT fontWeight,[None] DWRITE_FONT_STYLE fontStyle,[None] DWRITE_FONT_STRETCH fontStretch,[None] FLOAT fontSize,[In] const wchar* localeName,[Out] IDWriteTextFormat** textFormat) + + + + Creates a text format object used for text layout. + + an instance of + An array of characters that contains the name of the font family + A value that indicates the font weight for the text object created by this method. + A value that indicates the font style for the text object created by this method. + A value that indicates the font stretch for the text object created by this method. + The logical size of the font in DIP ("device-independent pixel") units. A DIP equals 1/96 inch. + HRESULT CreateTextFormat([In] const wchar* fontFamilyName,[None] IDWriteFontCollection* fontCollection,[None] DWRITE_FONT_WEIGHT fontWeight,[None] DWRITE_FONT_STYLE fontStyle,[None] DWRITE_FONT_STRETCH fontStretch,[None] FLOAT fontSize,[In] const wchar* localeName,[Out] IDWriteTextFormat** textFormat) + + + + Creates a text format object used for text layout. + + an instance of + An array of characters that contains the name of the font family + A pointer to a font collection object. When this is NULL, indicates the system font collection. + A value that indicates the font weight for the text object created by this method. + A value that indicates the font style for the text object created by this method. + A value that indicates the font stretch for the text object created by this method. + The logical size of the font in DIP ("device-independent pixel") units. A DIP equals 1/96 inch. + HRESULT CreateTextFormat([In] const wchar* fontFamilyName,[None] IDWriteFontCollection* fontCollection,[None] DWRITE_FONT_WEIGHT fontWeight,[None] DWRITE_FONT_STYLE fontStyle,[None] DWRITE_FONT_STRETCH fontStretch,[None] FLOAT fontSize,[In] const wchar* localeName,[Out] IDWriteTextFormat** textFormat) + + + + Creates a text format object used for text layout. + + an instance of + An array of characters that contains the name of the font family + A pointer to a font collection object. When this is NULL, indicates the system font collection. + A value that indicates the font weight for the text object created by this method. + A value that indicates the font style for the text object created by this method. + A value that indicates the font stretch for the text object created by this method. + The logical size of the font in DIP ("device-independent pixel") units. A DIP equals 1/96 inch. + An array of characters that contains the locale name. + HRESULT CreateTextFormat([In] const wchar* fontFamilyName,[None] IDWriteFontCollection* fontCollection,[None] DWRITE_FONT_WEIGHT fontWeight,[None] DWRITE_FONT_STYLE fontStyle,[None] DWRITE_FONT_STRETCH fontStretch,[None] FLOAT fontSize,[In] const wchar* localeName,[Out] IDWriteTextFormat** textFormat) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Sets the alignment of text in a paragraph, relative to the leading and trailing edge of a layout box for a IDWriteTextFormat interface. + + + The text can be aligned to the leading or trailing edge of the layout box, or it can be centered. The following illustration shows text with the alignment set to DWRITE_TEXT_ALIGNMENT_LEADING, DWRITE_TEXT_ALIGNMENT_CENTER, and DWRITE_TEXT_ALIGNMENT_TRAILING, respectively. ? Illustration of text paragraphs with leading, centered, and trailing alignment ? Note??The alignment is dependent on reading direction, the above is for left-to-right reading direction. For right-to-left reading direction it would be the opposite. See for more information. + + The text alignment option being set for the paragraph of type DWRITE_TEXT_ALIGNMENT. For more information, see Remarks. + The method can return one of the following values. Return codeDescription S_OK The method succeeded. E_INVALIDARG The textAlignment argument is invalid. ? + HRESULT IDWriteTextFormat::SetTextAlignment([None] DWRITE_TEXT_ALIGNMENT textAlignment) + + + + Sets the alignment option of a paragraph relative to the layout box's top and bottom edge. + + The paragraph alignment option being set for a paragraph; see DWRITE_PARAGRAPH_ALIGNMENT for more information. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextFormat::SetParagraphAlignment([None] DWRITE_PARAGRAPH_ALIGNMENT paragraphAlignment) + + + + Sets the word wrapping option. + + The word wrapping option being set for a paragraph; see for more information. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextFormat::SetWordWrapping([None] DWRITE_WORD_WRAPPING wordWrapping) + + + + Sets the paragraph reading direction. + + The text reading direction (for example, for languages, such as Arabic, that read from right to left) for a paragraph. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextFormat::SetReadingDirection([None] DWRITE_READING_DIRECTION readingDirection) + + + + Sets the paragraph flow direction. + + The paragraph flow direction; see for more information. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextFormat::SetFlowDirection([None] DWRITE_FLOW_DIRECTION flowDirection) + + + + Sets a fixed distance between two adjacent tab stops. + + The fixed distance between two adjacent tab stops. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextFormat::SetIncrementalTabStop([None] float incrementalTabStop) + + + + Sets trimming options for text overflowing the layout width. + + Text trimming options. + Application-defined omission sign. This parameter may be NULL. See for more information. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextFormat::SetTrimming([In] const DWRITE_TRIMMING* trimmingOptions,[None] IDWriteInlineObject* trimmingSign) + + + + Sets the line spacing. + + + For the default method, spacing depends solely on the content. For uniform spacing, the specified line height overrides the content. + + Specifies how line height is being determined; see for more information. + The line height, or distance between one baseline to another. + The distance from top of line to baseline. A reasonable ratio to lineSpacing is 80 percent. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextFormat::SetLineSpacing([None] DWRITE_LINE_SPACING_METHOD lineSpacingMethod,[None] float lineSpacing,[None] float baseline) + + + + Gets the alignment option of text relative to the layout box's leading and trailing edge. + + Returns the text alignment option of the current paragraph. + DWRITE_TEXT_ALIGNMENT IDWriteTextFormat::GetTextAlignment() + + + + Gets the alignment option of a paragraph which is relative to the top and bottom edges of a layout box. + + A value that indicates the current paragraph alignment option. + DWRITE_PARAGRAPH_ALIGNMENT IDWriteTextFormat::GetParagraphAlignment() + + + + Gets the word wrapping option. + + Returns the word wrapping option; see for more information. + DWRITE_WORD_WRAPPING IDWriteTextFormat::GetWordWrapping() + + + + Gets the current reading direction for text in a paragraph. + + A value that indicates the current reading direction for text in a paragraph. + DWRITE_READING_DIRECTION IDWriteTextFormat::GetReadingDirection() + + + + Gets the direction that text lines flow. + + The direction that text lines flow within their parent container. For example, DWRITE_FLOW_DIRECTION_TOP_TO_BOTTOM indicates that text lines are placed from top to bottom. + DWRITE_FLOW_DIRECTION IDWriteTextFormat::GetFlowDirection() + + + + Gets the incremental tab stop position. + + The incremental tab stop value. + float IDWriteTextFormat::GetIncrementalTabStop() + + + + Gets the trimming options for text that overflows the layout box. + + When this method returns, it contains a reference to a structure that holds the text trimming options for the overflowing text. + When this method returns, contains an address of a reference to a trimming omission sign. This parameter may be NULL. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextFormat::GetTrimming([Out] DWRITE_TRIMMING* trimmingOptions,[Out] IDWriteInlineObject** trimmingSign) + + + + Gets the line spacing adjustment set for a multiline text paragraph. + + A value that indicates how line height is determined. + When this method returns, contains the line height, or distance between one baseline to another. + When this method returns, contains the distance from top of line to baseline. A reasonable ratio to lineSpacing is 80 percent. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextFormat::GetLineSpacing([Out] DWRITE_LINE_SPACING_METHOD* lineSpacingMethod,[Out] float* lineSpacing,[Out] float* baseline) + + + + Gets the current font collection. + + When this method returns, contains an address of a reference to the font collection being used for the current text. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextFormat::GetFontCollection([Out] IDWriteFontCollection** fontCollection) + + + + Gets the length of the font family name. + + The size of the character array, in character count, not including the terminated NULL character. + int IDWriteTextFormat::GetFontFamilyNameLength() + + + + Gets a copy of the font family name. + + When this method returns, contains a reference to a character array, which is null-terminated, that receives the current font family name. The buffer allocated for this array should be at least the size, in elements, of nameSize. + The size of the fontFamilyName character array, in character count, including the terminated NULL character. To find the size of fontFamilyName, use {{GetFontFamilyNameLength}}. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextFormat::GetFontFamilyName([Out, Buffer] wchar_t* fontFamilyName,[None] int nameSize) + + + + Gets the font weight of the text. + + A value that indicates the type of weight (such as normal, bold, or black). + DWRITE_FONT_WEIGHT IDWriteTextFormat::GetFontWeight() + + + + Gets the font style of the text. + + A value which indicates the type of font style (such as slope or incline). + DWRITE_FONT_STYLE IDWriteTextFormat::GetFontStyle() + + + + Gets the font stretch of the text. + + A value which indicates the type of font stretch (such as normal or condensed). + DWRITE_FONT_STRETCH IDWriteTextFormat::GetFontStretch() + + + + Gets the font size in DIP unites. + + The current font size in DIP units. + float IDWriteTextFormat::GetFontSize() + + + + Gets the length of the locale name. + + The size of the character array in character count, not including the terminated NULL character. + int IDWriteTextFormat::GetLocaleNameLength() + + + + Gets a copy of the locale name. + + Contains a character array that receives the current locale name. + The size of the character array, in character count, including the terminated NULL character. Use {{GetLocaleNameLength}} to get the size of the locale name character array. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextFormat::GetLocaleName([Out, Buffer] wchar_t* localeName,[None] int nameSize) + + + + Gets a copy of the font family name. + + the current font family name. + HRESULT IDWriteTextFormat::GetFontFamilyName([Out, Buffer] wchar_t* fontFamilyName,[None] int nameSize) + + + + Gets a copy of the locale name. + + the current locale name. + HRESULT IDWriteTextFormat::GetLocaleName([Out, Buffer] wchar_t* localeName,[None] int nameSize) + + + + Gets the alignment option of text relative to the layout box's leading and trailing edge. + + DWRITE_TEXT_ALIGNMENT IDWriteTextFormat::GetTextAlignment() + + + + Gets the alignment option of a paragraph which is relative to the top and bottom edges of a layout box. + + DWRITE_PARAGRAPH_ALIGNMENT IDWriteTextFormat::GetParagraphAlignment() + + + + Gets the word wrapping option. + + DWRITE_WORD_WRAPPING IDWriteTextFormat::GetWordWrapping() + + + + Gets the current reading direction for text in a paragraph. + + DWRITE_READING_DIRECTION IDWriteTextFormat::GetReadingDirection() + + + + Gets the direction that text lines flow. + + DWRITE_FLOW_DIRECTION IDWriteTextFormat::GetFlowDirection() + + + + Gets the incremental tab stop position. + + float IDWriteTextFormat::GetIncrementalTabStop() + + + + Gets the current font collection. + + HRESULT IDWriteTextFormat::GetFontCollection([Out] IDWriteFontCollection** fontCollection) + + + + Gets the font weight of the text. + + DWRITE_FONT_WEIGHT IDWriteTextFormat::GetFontWeight() + + + + Gets the font style of the text. + + DWRITE_FONT_STYLE IDWriteTextFormat::GetFontStyle() + + + + Gets the font stretch of the text. + + DWRITE_FONT_STRETCH IDWriteTextFormat::GetFontStretch() + + + + Gets the font size in DIP unites. + + float IDWriteTextFormat::GetFontSize() + + + + The IDWriteTextLayout interface represents a block of text after it has been fully analyzed and formatted. + + IDWriteTextLayout + + + + Takes a string, text format, and associated constraints, and produces an object that represents the fully analyzed and formatted result. + + an instance of + An array of characters that contains the string to create a new object from. This array must be of length stringLength and can contain embedded NULL characters. + A pointer to an object that indicates the format to apply to the string. + The width of the layout box. + The height of the layout box. + HRESULT CreateTextLayout([In, Buffer] const wchar* string,[None] UINT32 stringLength,[None] IDWriteTextFormat* textFormat,[None] FLOAT maxWidth,[None] FLOAT maxHeight,[Out] IDWriteTextLayout** textLayout) + + + + Create a Gdi Compatible TextLayout. Takes a string, format, and associated constraints, and produces an object representing the result, formatted for a particular display resolution and measuring mode. + + + The resulting text layout should only be used for the intended resolution, and for cases where text scalability is desired {{CreateTextLayout}} should be used instead. + + an instance of + An array of characters that contains the string to create a new object from. This array must be of length stringLength and can contain embedded NULL characters. + The text formatting object to apply to the string. + The width of the layout box. + The height of the layout box. + The number of physical pixels per DIP (device independent pixel). For example, if rendering onto a 96 DPI device pixelsPerDip is 1. If rendering onto a 120 DPI device pixelsPerDip is 1.25 (120/96). + Instructs the text layout to use the same metrics as GDI bi-level text when set to FALSE. When set to TRUE, instructs the text layout to use the same metrics as text measured by GDI using a font created with CLEARTYPE_NATURAL_QUALITY. + HRESULT IDWriteFactory::CreateGdiCompatibleTextLayout([In, Buffer] const wchar_t* string,[None] int stringLength,[None] IDWriteTextFormat* textFormat,[None] float layoutWidth,[None] float layoutHeight,[None] float pixelsPerDip,[In, Optional] const DWRITE_MATRIX* transform,[None] BOOL useGdiNatural,[Out] IDWriteTextLayout** textLayout) + + + + Create a Gdi Compatible TextLayout. Takes a string, format, and associated constraints, and produces an object representing the result, formatted for a particular display resolution and measuring mode. + + + The resulting text layout should only be used for the intended resolution, and for cases where text scalability is desired {{CreateTextLayout}} should be used instead. + + an instance of + An array of characters that contains the string to create a new object from. This array must be of length stringLength and can contain embedded NULL characters. + The text formatting object to apply to the string. + The width of the layout box. + The height of the layout box. + The number of physical pixels per DIP (device independent pixel). For example, if rendering onto a 96 DPI device pixelsPerDip is 1. If rendering onto a 120 DPI device pixelsPerDip is 1.25 (120/96). + An optional transform applied to the glyphs and their positions. This transform is applied after the scaling specifies the font size and pixels per DIP. + Instructs the text layout to use the same metrics as GDI bi-level text when set to FALSE. When set to TRUE, instructs the text layout to use the same metrics as text measured by GDI using a font created with CLEARTYPE_NATURAL_QUALITY. + HRESULT IDWriteFactory::CreateGdiCompatibleTextLayout([In, Buffer] const wchar_t* string,[None] int stringLength,[None] IDWriteTextFormat* textFormat,[None] float layoutWidth,[None] float layoutHeight,[None] float pixelsPerDip,[In, Optional] const DWRITE_MATRIX* transform,[None] BOOL useGdiNatural,[Out] IDWriteTextLayout** textLayout) + + + + Draws text using the specified client drawing context. + + + To draw text with this method, a textLayout object needs to be created by the application using . After the textLayout object is obtained, the application calls the IDWriteTextLayout::Draw method to draw the text, decorations, and inline objects. The actual drawing is done through the callback interface passed in as the textRenderer argument; there, the corresponding DrawGlyphRun API is called. + + Pointer to the set of callback functions used to draw parts of a text string. + The x-coordinate of the layout's left side. + The y-coordinate of the layout's top side. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Draw([None] void* clientDrawingContext,[None] IDWriteTextRenderer* renderer,[None] FLOAT originX,[None] FLOAT originY) + + + + Draws text using the specified client drawing context. + + + To draw text with this method, a textLayout object needs to be created by the application using . After the textLayout object is obtained, the application calls the IDWriteTextLayout::Draw method to draw the text, decorations, and inline objects. The actual drawing is done through the callback interface passed in as the textRenderer argument; there, the corresponding DrawGlyphRun API is called. + + An application-defined drawing context. + Pointer to the set of callback functions used to draw parts of a text string. + The x-coordinate of the layout's left side. + The y-coordinate of the layout's top side. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Draw([None] void* clientDrawingContext,[None] IDWriteTextRenderer* renderer,[None] FLOAT originX,[None] FLOAT originY) + + + + Retrieves logical properties and measurements of each glyph cluster. + + + If maxClusterCount is not large enough, then E_NOT_SUFFICIENT_BUFFER, which is equivalent to HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER), is returned and actualClusterCount is set to the number of clusters needed. + + Returns metrics, such as line-break or total advance width, for a glyph cluster. + HRESULT IDWriteTextLayout::GetClusterMetrics([Out, Buffer, Optional] DWRITE_CLUSTER_METRICS* clusterMetrics,[None] int maxClusterCount,[Out] int* actualClusterCount) + + + + Sets the application-defined drawing effect. + + + An , such as a color or gradient brush, can be set as a drawing effect if you are using the to draw text and that brush will be used to draw the specified range of text. This drawing effect is associated with the specified range and will be passed back to the application by way of the callback when the range is drawn at drawing time. + + Application-defined drawing effects that apply to the range. This data object will be passed back to the application's drawing callbacks for final rendering. + The text range to which this change applies. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::SetDrawingEffect([None] IUnknown* drawingEffect,[None] DWRITE_TEXT_RANGE textRange) + + + + Gets the application-defined drawing effect at the specified text position. + + The position of the text whose drawing effect is to be retrieved. + a reference to the current application-defined drawing effect. Usually this effect is a foreground brush that is used in glyph drawing. + HRESULT IDWriteTextLayout::GetDrawingEffect([None] int currentPosition,[Out] IUnknown** drawingEffect,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the application-defined drawing effect at the specified text position. + + The position of the text whose drawing effect is to be retrieved. + Contains the range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the drawing effect. + a reference to the current application-defined drawing effect. Usually this effect is a foreground brush that is used in glyph drawing. + HRESULT IDWriteTextLayout::GetDrawingEffect([None] int currentPosition,[Out] IUnknown** drawingEffect,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the font collection associated with the text at the specified position. + + The position of the text to inspect. + a reference to the current font collection. + HRESULT IDWriteTextLayout::GetFontCollection([None] int currentPosition,[Out] IDWriteFontCollection** fontCollection,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the font family name of the text at the specified position. + + The position of the text to examine. + the font family name + HRESULT IDWriteTextLayout::GetFontFamilyName([None] int currentPosition,[Out, Buffer] wchar_t* fontFamilyName,[None] int nameSize,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the font family name of the text at the specified position. + + The position of the text to examine. + The range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the font family name. + the font family name + HRESULT IDWriteTextLayout::GetFontFamilyName([None] int currentPosition,[Out, Buffer] wchar_t* fontFamilyName,[None] int nameSize,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the font em height of the text at the specified position. + + The position of the text to inspect. + the size of the font in ems of the text at the specified position. + HRESULT IDWriteTextLayout::GetFontSize([None] int currentPosition,[Out] float* fontSize,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the font stretch of the text at the specified position. + + The position of the text to inspect. + a value which indicates the type of font stretch (also known as width) being applied at the specified position. + HRESULT IDWriteTextLayout::GetFontStretch([None] int currentPosition,[Out] DWRITE_FONT_STRETCH* fontStretch,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the font style (also known as slope) of the text at the specified position. + + The position of the text to inspect. + a value which indicates the type of font style (also known as slope or incline) being applied at the specified position. + HRESULT IDWriteTextLayout::GetFontStyle([None] int currentPosition,[Out] DWRITE_FONT_STYLE* fontStyle,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the font weight of the text at the specified position. + + The position of the text to inspect. + a value which indicates the type of font weight being applied at the specified position. + HRESULT IDWriteTextLayout::GetFontWeight([None] int currentPosition,[Out] DWRITE_FONT_WEIGHT* fontWeight,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the inline object at the specified position. + + The specified text position. + an application-defined inline object. + HRESULT IDWriteTextLayout::GetInlineObject([None] int currentPosition,[Out] IDWriteInlineObject** inlineObject,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Retrieves the information about each individual text line of the text string. + + + If maxLineCount is not large enough E_NOT_SUFFICIENT_BUFFER, which is equivalent to HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER), is returned and *actualLineCount is set to the number of lines needed. + + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::GetLineMetrics([Out, Buffer, Optional] DWRITE_LINE_METRICS* lineMetrics,[None] int maxLineCount,[Out] int* actualLineCount) + + + + Gets the locale name of the text at the specified position. + + The position of the text to inspect. + the locale name of the text at the specified position. + HRESULT IDWriteTextLayout::GetLocaleName([None] int currentPosition,[Out, Buffer] wchar_t* localeName,[None] int nameSize,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the locale name of the text at the specified position. + + The position of the text to inspect. + The range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the locale name. + the locale name of the text at the specified position. + HRESULT IDWriteTextLayout::GetLocaleName([None] int currentPosition,[Out, Buffer] wchar_t* localeName,[None] int nameSize,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Get the strikethrough presence of the text at the specified position. + + The position of the text to inspect. + A Boolean flag that indicates whether strikethrough is present at the position indicated by currentPosition. + HRESULT IDWriteTextLayout::GetStrikethrough([None] int currentPosition,[Out] BOOL* hasStrikethrough,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the typography setting of the text at the specified position. + + The position of the text to inspect. + a reference to the current typography setting. + HRESULT IDWriteTextLayout::GetTypography([None] int currentPosition,[Out] IDWriteTypography** typography,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the underline presence of the text at the specified position. + + The current text position. + A Boolean flag that indicates whether underline is present at the position indicated by currentPosition. + HRESULT IDWriteTextLayout::GetUnderline([None] int currentPosition,[Out] BOOL* hasUnderline,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + The application calls this function passing in a specific pixel location relative to the top-left location of the layout box and obtains the information about the correspondent hit-test metrics of the text string where the hit-test has occurred. When the specified pixel location is outside the text string, the function sets the output value *isInside to FALSE. + + The pixel location X to hit-test, relative to the top-left location of the layout box. + The pixel location Y to hit-test, relative to the top-left location of the layout box. + An output flag that indicates whether the hit-test location is at the leading or the trailing side of the character. When the output *isInside value is set to FALSE, this value is set according to the output hitTestMetrics->textPosition value to represent the edge closest to the hit-test location. + An output flag that indicates whether the hit-test location is inside the text string. When FALSE, the position nearest the text's edge is returned. + The output geometry fully enclosing the hit-test location. When the output *isInside value is set to FALSE, this structure represents the geometry enclosing the edge closest to the hit-test location. + HRESULT IDWriteTextLayout::HitTestPoint([None] float pointX,[None] float pointY,[Out] BOOL* isTrailingHit,[Out] BOOL* isInside,[Out] DWRITE_HIT_TEST_METRICS* hitTestMetrics) + + + + The application calls this function to get a set of hit-test metrics corresponding to a range of text positions. One of the main usages is to implement highlight selection of the text string. The function returns E_NOT_SUFFICIENT_BUFFER, which is equivalent to HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER), when the buffer size of hitTestMetrics is too small to hold all the regions calculated by the function. In this situation, the function sets the output value *actualHitTestMetricsCount to the number of geometries calculated. The application is responsible for allocating a new buffer of greater size and calling the function again. A good value to use as an initial value for maxHitTestMetricsCount may be calculated from the following equation: maxHitTestMetricsCount = lineCount * maxBidiReorderingDepth where lineCount is obtained from the value of the output argument *actualLineCount (from the function IDWriteTextLayout::GetLineLengths), and the maxBidiReorderingDepth value from the DWRITE_TEXT_METRICS structure of the output argument *textMetrics (from the function IDWriteFactory::CreateTextLayout). + + The first text position of the specified range. + The number of positions of the specified range. + The origin pixel location X at the left of the layout box. This offset is added to the hit-test metrics returned. + The origin pixel location Y at the top of the layout box. This offset is added to the hit-test metrics returned. + a reference to a buffer of the output geometry fully enclosing the specified position range. The buffer must be at least as large as maxHitTestMetricsCount. + HRESULT IDWriteTextLayout::HitTestTextRange([None] int textPosition,[None] int textLength,[None] float originX,[None] float originY,[Out, Buffer, Optional] DWRITE_HIT_TEST_METRICS* hitTestMetrics,[None] int maxHitTestMetricsCount,[Out] int* actualHitTestMetricsCount) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Sets the layout maximum width. + + A value that indicates the maximum width of the layout box. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::SetMaxWidth([None] float maxWidth) + + + + Sets the layout maximum height. + + A value that indicates the maximum height of the layout box. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::SetMaxHeight([None] float maxHeight) + + + + Sets the font collection. + + The font collection to set. + Text range to which this change applies. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::SetFontCollection([None] IDWriteFontCollection* fontCollection,[None] DWRITE_TEXT_RANGE textRange) + + + + Sets null-terminated font family name for text within a specified text range. + + The font family name that applies to the entire text string within the range specified by textRange. + Text range to which this change applies. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::SetFontFamilyName([In] const wchar_t* fontFamilyName,[None] DWRITE_TEXT_RANGE textRange) + + + + Sets the font weight for text within a text range specified by a structure. + + + The font weight can be set to one of the predefined font weight values provided in the enumeration or an integer from 1 to 999. Values outside this range will cause the method to fail with an E_INVALIDARG return value. The following illustration shows an example of Normal and UltraBold weights for the Palatino Linotype typeface. ? Illustration of the letter "W" in Normal and UltraBold weights ? + + The font weight to be set for text within the range specified by textRange. + Text range to which this change applies. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::SetFontWeight([None] DWRITE_FONT_WEIGHT fontWeight,[None] DWRITE_TEXT_RANGE textRange) + + + + Sets the font style for text within a text range specified by a structure. + + + The font style can be set to Normal, Italic or Oblique. The following illustration shows three styles for the Palatino font. For more information, see . ? Illustration of normal, italic, and oblique font styles for the Palatino font ? + + The font style to be set for text within a range specified by textRange. + The text range to which this change applies. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::SetFontStyle([None] DWRITE_FONT_STYLE fontStyle,[None] DWRITE_TEXT_RANGE textRange) + + + + Sets the font stretch for text within a specified text range. + + A value which indicates the type of font stretch for text within the range specified by textRange. + Text range to which this change applies. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::SetFontStretch([None] DWRITE_FONT_STRETCH fontStretch,[None] DWRITE_TEXT_RANGE textRange) + + + + Sets the font size in DIP units for text within a specified text range. + + The font size in DIP units to be set for text in the range specified by textRange. + Text range to which this change applies. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::SetFontSize([None] float fontSize,[None] DWRITE_TEXT_RANGE textRange) + + + + Sets underlining for text within a specified text range. + + A Boolean flag that indicates whether underline takes place within a specified text range. + Text range to which this change applies. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::SetUnderline([None] BOOL hasUnderline,[None] DWRITE_TEXT_RANGE textRange) + + + + Sets strikethrough for text within a specified text range. + + A Boolean flag that indicates whether strikethrough takes place in the range specified by textRange. + Text range to which this change applies. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::SetStrikethrough([None] BOOL hasStrikethrough,[None] DWRITE_TEXT_RANGE textRange) + + + + Sets the application-defined drawing effect. + + + An , such as a color or gradient brush, can be set as a drawing effect if you are using the to draw text and that brush will be used to draw the specified range of text. This drawing effect is associated with the specified range and will be passed back to the application by way of the callback when the range is drawn at drawing time. + + Application-defined drawing effects that apply to the range. This data object will be passed back to the application's drawing callbacks for final rendering. + The text range to which this change applies. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::SetDrawingEffect([None] void* drawingEffect,[None] DWRITE_TEXT_RANGE textRange) + + + + Sets the inline object. + + + The application may call this function to specify the set of properties describing an application-defined inline object for specific range. This inline object applies to the specified range and will be passed back to the application by way of the DrawInlineObject callback when the range is drawn. Any text in that range will be suppressed. + + An application-defined inline object. + Text range to which this change applies. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::SetInlineObject([None] IDWriteInlineObject* inlineObject,[None] DWRITE_TEXT_RANGE textRange) + + + + Sets font typography features for text within a specified text range. + + Pointer to font typography settings. + Text range to which this change applies. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::SetTypography([None] IDWriteTypography* typography,[None] DWRITE_TEXT_RANGE textRange) + + + + Sets the locale name for text within a specified text range. + + A null-terminated locale name string. + Text range to which this change applies. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::SetLocaleName([In] const wchar_t* localeName,[None] DWRITE_TEXT_RANGE textRange) + + + + Gets the layout maximum width. + + Returns the layout maximum width. + float IDWriteTextLayout::GetMaxWidth() + + + + Gets the layout maximum height. + + The layout maximum height. + float IDWriteTextLayout::GetMaxHeight() + + + + Gets the font collection associated with the text at the specified position. + + The position of the text to inspect. + The range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the underline. + Contains an address of a reference to the current font collection. + HRESULT IDWriteTextLayout::GetFontCollection([None] int currentPosition,[Out] IDWriteFontCollection** fontCollection,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Get the length of the font family name at the current position. + + The current text position. + When this method returns, contains the size of the character array containing the font family name, in character count, not including the terminated NULL character. + The range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the font family. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::GetFontFamilyNameLength([None] int currentPosition,[Out] int* nameLength,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Copies the font family name of the text at the specified position. + + The position of the text to examine. + When this method returns, contains an array of characters that receives the current font family name. You must allocate storage for this parameter. + The size of the character array in character count including the terminated NULL character. + The range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the font family name. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::GetFontFamilyName([None] int currentPosition,[Out, Buffer] wchar_t* fontFamilyName,[None] int nameSize,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the font weight of the text at the specified position. + + The position of the text to inspect. + The range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the font weight. + When this method returns, contains a value which indicates the type of font weight being applied at the specified position. + HRESULT IDWriteTextLayout::GetFontWeight([None] int currentPosition,[Out] DWRITE_FONT_WEIGHT* fontWeight,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the font style (also known as slope) of the text at the specified position. + + The position of the text to inspect. + The range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the font style. + When this method returns, contains a value which indicates the type of font style (also known as slope or incline) being applied at the specified position. + HRESULT IDWriteTextLayout::GetFontStyle([None] int currentPosition,[Out] DWRITE_FONT_STYLE* fontStyle,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the font stretch of the text at the specified position. + + The position of the text to inspect. + The range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the font stretch. + When this method returns, contains a value which indicates the type of font stretch (also known as width) being applied at the specified position. + HRESULT IDWriteTextLayout::GetFontStretch([None] int currentPosition,[Out] DWRITE_FONT_STRETCH* fontStretch,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the font em height of the text at the specified position. + + The position of the text to inspect. + The range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the font size. + When this method returns, contains the size of the font in ems of the text at the specified position. + HRESULT IDWriteTextLayout::GetFontSize([None] int currentPosition,[Out] float* fontSize,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the underline presence of the text at the specified position. + + The current text position. + The range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the underline. + A Boolean flag that indicates whether underline is present at the position indicated by currentPosition. + HRESULT IDWriteTextLayout::GetUnderline([None] int currentPosition,[Out] BOOL* hasUnderline,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Get the strikethrough presence of the text at the specified position. + + The position of the text to inspect. + Contains the range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to strikethrough. + A Boolean flag that indicates whether strikethrough is present at the position indicated by currentPosition. + HRESULT IDWriteTextLayout::GetStrikethrough([None] int currentPosition,[Out] BOOL* hasStrikethrough,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the application-defined drawing effect at the specified text position. + + The position of the text whose drawing effect is to be retrieved. + Contains the range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the drawing effect. + When this method returns, contains an address of a reference to the current application-defined drawing effect. Usually this effect is a foreground brush that is used in glyph drawing. + HRESULT IDWriteTextLayout::GetDrawingEffect([None] int currentPosition,[Out] void** drawingEffect,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the inline object at the specified position. + + The specified text position. + The range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the inline object. + Contains the application-defined inline object. + HRESULT IDWriteTextLayout::GetInlineObject([None] int currentPosition,[Out] IDWriteInlineObject** inlineObject,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the typography setting of the text at the specified position. + + The position of the text to inspect. + The range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the typography. + When this method returns, contains an address of a reference to the current typography setting. + HRESULT IDWriteTextLayout::GetTypography([None] int currentPosition,[Out] IDWriteTypography** typography,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the length of the locale name of the text at the specified position. + + The position of the text to inspect. + Size of the character array, in character count, not including the terminated NULL character. + The range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the locale name. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::GetLocaleNameLength([None] int currentPosition,[Out] int* nameLength,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Gets the locale name of the text at the specified position. + + The position of the text to inspect. + When this method returns, contains the character array receiving the current locale name. + Size of the character array, in character count, including the terminated NULL character. + The range of text that has the same formatting as the text at the position specified by currentPosition. This means the run has the exact formatting as the position specified, including but not limited to the locale name. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::GetLocaleName([None] int currentPosition,[Out, Buffer] wchar_t* localeName,[None] int nameSize,[Out, Optional] DWRITE_TEXT_RANGE* textRange) + + + + Draws text using the specified client drawing context. + + + To draw text with this method, a textLayout object needs to be created by the application using . After the textLayout object is obtained, the application calls the IDWriteTextLayout::Draw method to draw the text, decorations, and inline objects. The actual drawing is done through the callback interface passed in as the textRenderer argument; there, the corresponding DrawGlyphRun API is called. + + An application-defined drawing context. + Pointer to the set of callback functions used to draw parts of a text string. + The x-coordinate of the layout's left side. + The y-coordinate of the layout's top side. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::Draw([None] void* clientDrawingContext,[None] IDWriteTextRenderer* renderer,[None] float originX,[None] float originY) + + + + Retrieves the information about each individual text line of the text string. + + + If maxLineCount is not large enough E_NOT_SUFFICIENT_BUFFER, which is equivalent to HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER), is returned and *actualLineCount is set to the number of lines needed. + + When this method returns, contains a reference to an array of structures containing various calculated length values of individual text lines. + The maximum size of the lineMetrics array. + When this method returns, contains the actual size of the lineMetrics array that is needed. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::GetLineMetrics([Out, Buffer, Optional] DWRITE_LINE_METRICS* lineMetrics,[None] int maxLineCount,[Out] int* actualLineCount) + + + + Retrieves overall metrics for the formatted string. + + When this method returns, contains the measured distances of text and associated content after being formatted. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::GetMetrics([Out] DWRITE_TEXT_METRICS* textMetrics) + + + + Returns the overhangs (in DIPs) of the layout and all objects contained in it, including text glyphs and inline objects. + + + Underlines and strikethroughs do not contribute to the black box determination, since these are actually drawn by the renderer, which is allowed to draw them in any variety of styles. + + Overshoots of visible extents (in DIPs) outside the layout. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::GetOverhangMetrics([Out] DWRITE_OVERHANG_METRICS* overhangs) + + + + Retrieves logical properties and measurements of each glyph cluster. + + + If maxClusterCount is not large enough, then E_NOT_SUFFICIENT_BUFFER, which is equivalent to HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER), is returned and actualClusterCount is set to the number of clusters needed. + + When this method returns, contains metrics, such as line-break or total advance width, for a glyph cluster. + The maximum size of the clusterMetrics array. + When this method returns, contains the actual size of the clusterMetrics array that is needed. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::GetClusterMetrics([Out, Buffer, Optional] DWRITE_CLUSTER_METRICS* clusterMetrics,[None] int maxClusterCount,[Out] int* actualClusterCount) + + + + Determines the minimum possible width the layout can be set to without emergency breaking between the characters of whole words occurring. + + Minimum width. + HRESULT IDWriteTextLayout::DetermineMinWidth([Out] float* minWidth) + + + + The application calls this function passing in a specific pixel location relative to the top-left location of the layout box and obtains the information about the correspondent hit-test metrics of the text string where the hit-test has occurred. When the specified pixel location is outside the text string, the function sets the output value *isInside to FALSE. + + The pixel location X to hit-test, relative to the top-left location of the layout box. + The pixel location Y to hit-test, relative to the top-left location of the layout box. + An output flag that indicates whether the hit-test location is at the leading or the trailing side of the character. When the output *isInside value is set to FALSE, this value is set according to the output hitTestMetrics->textPosition value to represent the edge closest to the hit-test location. + An output flag that indicates whether the hit-test location is inside the text string. When FALSE, the position nearest the text's edge is returned. + The output geometry fully enclosing the hit-test location. When the output *isInside value is set to FALSE, this structure represents the geometry enclosing the edge closest to the hit-test location. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::HitTestPoint([None] float pointX,[None] float pointY,[Out] BOOL* isTrailingHit,[Out] BOOL* isInside,[Out] DWRITE_HIT_TEST_METRICS* hitTestMetrics) + + + + The application calls this function to get the pixel location relative to the top-left of the layout box given the text position and the logical side of the position. This function is normally used as part of caret positioning of text where the caret is drawn at the location corresponding to the current text editing position. It may also be used as a way to programmatically obtain the geometry of a particular text position in UI automation. + + The text position used to get the pixel location. + A Boolean flag that indicates whether the pixel location is of the leading or the trailing side of the specified text position. + When this method returns, contains the output pixel location X, relative to the top-left location of the layout box. + When this method returns, contains the output pixel location Y, relative to the top-left location of the layout box. + When this method returns, contains the output geometry fully enclosing the specified text position. + HRESULT IDWriteTextLayout::HitTestTextPosition([None] int textPosition,[None] BOOL isTrailingHit,[Out] float* pointX,[Out] float* pointY,[Out] DWRITE_HIT_TEST_METRICS* hitTestMetrics) + + + + The application calls this function to get a set of hit-test metrics corresponding to a range of text positions. One of the main usages is to implement highlight selection of the text string. The function returns E_NOT_SUFFICIENT_BUFFER, which is equivalent to HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER), when the buffer size of hitTestMetrics is too small to hold all the regions calculated by the function. In this situation, the function sets the output value *actualHitTestMetricsCount to the number of geometries calculated. The application is responsible for allocating a new buffer of greater size and calling the function again. A good value to use as an initial value for maxHitTestMetricsCount may be calculated from the following equation: maxHitTestMetricsCount = lineCount * maxBidiReorderingDepth where lineCount is obtained from the value of the output argument *actualLineCount (from the function IDWriteTextLayout::GetLineLengths), and the maxBidiReorderingDepth value from the DWRITE_TEXT_METRICS structure of the output argument *textMetrics (from the function IDWriteFactory::CreateTextLayout). + + The first text position of the specified range. + The number of positions of the specified range. + The origin pixel location X at the left of the layout box. This offset is added to the hit-test metrics returned. + The origin pixel location Y at the top of the layout box. This offset is added to the hit-test metrics returned. + When this method returns, contains a reference to a buffer of the output geometry fully enclosing the specified position range. The buffer must be at least as large as maxHitTestMetricsCount. + Maximum number of boxes hitTestMetrics could hold in its buffer memory. + Actual number of geometries hitTestMetrics holds in its buffer memory. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTextLayout::HitTestTextRange([None] int textPosition,[None] int textLength,[None] float originX,[None] float originY,[Out, Buffer, Optional] DWRITE_HIT_TEST_METRICS* hitTestMetrics,[None] int maxHitTestMetricsCount,[Out] int* actualHitTestMetricsCount) + + + + Gets the layout maximum width. + + float IDWriteTextLayout::GetMaxWidth() + + + + Gets the layout maximum height. + + float IDWriteTextLayout::GetMaxHeight() + + + + Retrieves overall metrics for the formatted string. + + HRESULT IDWriteTextLayout::GetMetrics([Out] DWRITE_TEXT_METRICS* textMetrics) + + + + Returns the overhangs (in DIPs) of the layout and all objects contained in it, including text glyphs and inline objects. + + + Underlines and strikethroughs do not contribute to the black box determination, since these are actually drawn by the renderer, which is allowed to draw them in any variety of styles. + + HRESULT IDWriteTextLayout::GetOverhangMetrics([Out] DWRITE_OVERHANG_METRICS* overhangs) + + + + Specifies a range of text positions where format is applied in the text represented by an object. + + DWRITE_TEXT_RANGE + + + + Initializes a new instance of the struct. + + The start position. + The length. + + + + The start position of the text range. + + int startPosition + + + + The number positions in the text range. + + int length + + + + Represents a set of application-defined callbacks that perform rendering of text, inline objects, and decorations such as underlines. + + IDWriteTextRenderer + + + + IDWriteTextLayout::Draw calls this function to instruct the client to render a run of glyphs. + + + The function calls this callback function with all the information about glyphs to render. The application implements this callback by mostly delegating the call to the underlying platform's graphics API such as {{Direct2D}} to draw glyphs on the drawing context. An application that uses GDI can implement this callback in terms of the method. + + The application-defined drawing context passed to . + The pixel location (X-coordinate) at the baseline origin of the glyph run. + The pixel location (Y-coordinate) at the baseline origin of the glyph run. + The measuring method for glyphs in the run, used with the other properties to determine the rendering mode. + Pointer to the glyph run instance to render. + A pointer to the optional glyph run description instance which contains properties of the characters associated with this run. + Application-defined drawing effects for the glyphs to render. Usually this argument represents effects such as the foreground brush filling the interior of text. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT DrawGlyphRun([None] void* clientDrawingContext,[None] FLOAT baselineOriginX,[None] FLOAT baselineOriginY,[None] DWRITE_MEASURING_MODE measuringMode,[In] const DWRITE_GLYPH_RUN* glyphRun,[In] const DWRITE_GLYPH_RUN_DESCRIPTION* glyphRunDescription,[None] IUnknown* clientDrawingEffect) + + + + IDWriteTextLayout::Draw calls this function to instruct the client to draw an underline. + + + A single underline can be broken into multiple calls, depending on how the formatting changes attributes. If font sizes/styles change within an underline, the thickness and offset will be averaged weighted according to characters. To get an appropriate starting pixel position, add underline::offset to the baseline. Otherwise there will be no spacing between the text. The x coordinate will always be passed as the left side, regardless of text directionality. This simplifies drawing and reduces the problem of round-off that could potentially cause gaps or a double stamped alpha blend. To avoid alpha overlap, round the end points to the nearest device pixel. + + The application-defined drawing context passed to IDWriteTextLayout::Draw. + The pixel location (X-coordinate) at the baseline origin of the run where underline applies. + The pixel location (Y-coordinate) at the baseline origin of the run where underline applies. + Pointer to a structure containing underline logical information. + Application-defined effect to apply to the underline. Usually this argument represents effects such as the foreground brush filling the interior of a line. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT DrawUnderline([None] void* clientDrawingContext,[None] FLOAT baselineOriginX,[None] FLOAT baselineOriginY,[In] const DWRITE_UNDERLINE* underline,[None] IUnknown* clientDrawingEffect) + + + + IDWriteTextLayout::Draw calls this function to instruct the client to draw a strikethrough. + + + A single strikethrough can be broken into multiple calls, depending on how the formatting changes attributes. Strikethrough is not averaged across font sizes/styles changes. To get an appropriate starting pixel position, add strikethrough::offset to the baseline. Like underlines, the x coordinate will always be passed as the left side, regardless of text directionality. + + The application-defined drawing context passed to IDWriteTextLayout::Draw. + The pixel location (X-coordinate) at the baseline origin of the run where strikethrough applies. + The pixel location (Y-coordinate) at the baseline origin of the run where strikethrough applies. + Pointer to a structure containing strikethrough logical information. + Application-defined effect to apply to the strikethrough. Usually this argument represents effects such as the foreground brush filling the interior of a line. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT DrawStrikethrough([None] void* clientDrawingContext,[None] FLOAT baselineOriginX,[None] FLOAT baselineOriginY,[In] const DWRITE_STRIKETHROUGH* strikethrough,[None] IUnknown* clientDrawingEffect) + + + + IDWriteTextLayout::Draw calls this application callback when it needs to draw an inline object. + + The application-defined drawing context passed to IDWriteTextLayout::Draw. + X-coordinate at the top-left corner of the inline object. + Y-coordinate at the top-left corner of the inline object. + The application-defined inline object set using IDWriteTextFormat::SetInlineObject. + A Boolean flag that indicates whether the object's baseline runs alongside the baseline axis of the line. + A Boolean flag that indicates whether the object is in a right-to-left context, hinting that the drawing may want to mirror the normal image. + Application-defined drawing effects for the glyphs to render. Usually this argument represents effects such as the foreground brush filling the interior of a line. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT DrawInlineObject([None] void* clientDrawingContext,[None] FLOAT originX,[None] FLOAT originY,[None] IDWriteInlineObject* inlineObject,[None] BOOL isSideways,[None] BOOL isRightToLeft,[None] IUnknown* clientDrawingEffect) + + + + Represents a bitmap that has been bound to an . + + ID2D1Bitmap + + + + Represents a Direct2D drawing resource. + + ID2D1Resource + + + + Initializes a new instance of the class. + + The native pointer. + + + + Retrieves the factory associated with this resource. + + When this method returns, contains a reference to a reference to the factory that created this resource. This parameter is passed uninitialized. + void ID2D1Resource::GetFactory([Out] ID2D1Factory** factory) + + + + Retrieves the factory associated with this resource. + + void ID2D1Resource::GetFactory([Out] ID2D1Factory** factory) + + + + Creates a Direct2D bitmap from a pointer to in-memory source data. + + an instance of + The dimension of the bitmap to create in pixels. + HRESULT CreateBitmap([None] D2D1_SIZE_U size,[In, Optional] const void* srcData,[None] UINT32 pitch,[In] const D2D1_BITMAP_PROPERTIES* bitmapProperties,[Out] ID2D1Bitmap** bitmap) + + + + Creates a Direct2D bitmap from a pointer to in-memory source data. + + an instance of + The dimension of the bitmap to create in pixels. + The pixel format and dots per inch (DPI) of the bitmap to create. + HRESULT CreateBitmap([None] D2D1_SIZE_U size,[In, Optional] const void* srcData,[None] UINT32 pitch,[In] const D2D1_BITMAP_PROPERTIES* bitmapProperties,[Out] ID2D1Bitmap** bitmap) + + + + Creates a Direct2D bitmap from a pointer to in-memory source data. + + an instance of + The dimension of the bitmap to create in pixels. + A pointer to the memory location of the image data, or NULL to create an uninitialized bitmap. + The byte count of each scanline, which is equal to (the image width in pixels * the number of bytes per pixel) + memory padding. If srcData is NULL, this value is ignored. (Note that pitch is also sometimes called stride.) + HRESULT CreateBitmap([None] D2D1_SIZE_U size,[In, Optional] const void* srcData,[None] UINT32 pitch,[In] const D2D1_BITMAP_PROPERTIES* bitmapProperties,[Out] ID2D1Bitmap** bitmap) + + + + Creates a Direct2D bitmap from a pointer to in-memory source data. + + an instance of + The dimension of the bitmap to create in pixels. + A pointer to the memory location of the image data, or NULL to create an uninitialized bitmap. + The byte count of each scanline, which is equal to (the image width in pixels * the number of bytes per pixel) + memory padding. If srcData is NULL, this value is ignored. (Note that pitch is also sometimes called stride.) + The pixel format and dots per inch (DPI) of the bitmap to create. + HRESULT CreateBitmap([None] D2D1_SIZE_U size,[In, Optional] const void* srcData,[None] UINT32 pitch,[In] const D2D1_BITMAP_PROPERTIES* bitmapProperties,[Out] ID2D1Bitmap** bitmap) + + + + Creates an whose data is shared with another resource. + + an instance of + An that contains the data to share with the new ID2D1Bitmap. For more information, see the Remarks section. + HRESULT CreateSharedBitmap([In] REFIID riid,[InOut] void* data,[In, Optional] const D2D1_BITMAP_PROPERTIES* bitmapProperties,[Out] ID2D1Bitmap** bitmap) + + + + Creates an whose data is shared with another resource. + + an instance of + An that contains the data to share with the new ID2D1Bitmap. For more information, see the Remarks section. + The pixel format and DPI of the bitmap to create . The portion of the pixel format must match the of data or the method will fail, but the alpha modes don't have to match. To prevent a mismatch, you can pass NULL or the value obtained from the {{D2D1::PixelFormat}} helper function. The DPI settings do not have to match those of data. If both dpiX and dpiY are 0.0f, the default DPI, 96, is used. + HRESULT CreateSharedBitmap([In] REFIID riid,[InOut] void* data,[In, Optional] const D2D1_BITMAP_PROPERTIES* bitmapProperties,[Out] ID2D1Bitmap** bitmap) + + + + Creates an whose data is shared with another resource. + + an instance of + An that contains the data to share with the new ID2D1Bitmap. For more information, see the Remarks section. + HRESULT CreateSharedBitmap([In] REFIID riid,[InOut] void* data,[In, Optional] const D2D1_BITMAP_PROPERTIES* bitmapProperties,[Out] ID2D1Bitmap** bitmap) + + + + Creates an whose data is shared with another resource. + + an instance of + An that contains the data to share with the new ID2D1Bitmap. For more information, see the Remarks section. + The pixel format and DPI of the bitmap to create . The portion of the pixel format must match the of data or the method will fail, but the alpha modes don't have to match. To prevent a mismatch, you can pass NULL or the value obtained from the {{D2D1::PixelFormat}} helper function. The DPI settings do not have to match those of data. If both dpiX and dpiY are 0.0f, the default DPI, 96, is used. + HRESULT CreateSharedBitmap([In] REFIID riid,[InOut] void* data,[In, Optional] const D2D1_BITMAP_PROPERTIES* bitmapProperties,[Out] ID2D1Bitmap** bitmap) + + + + Copies the specified region from the specified bitmap into the current bitmap. + + + This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion, and will fail if the bitmap formats do not match. Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to {{EndDraw}} or {{Flush}}. + + The bitmap to copy from. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Bitmap::CopyFromBitmap([In, Optional] const D2D1_POINT_2U* destPoint,[In] ID2D1Bitmap* bitmap,[In, Optional] const D2D1_RECT_U* srcRect) + + + + Copies the specified region from the specified bitmap into the current bitmap. + + + This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion, and will fail if the bitmap formats do not match. Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to {{EndDraw}} or {{Flush}}. + + The bitmap to copy from. + In the current bitmap, the upper-left corner of the area to which the region specified by srcRect is copied. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Bitmap::CopyFromBitmap([In, Optional] const D2D1_POINT_2U* destPoint,[In] ID2D1Bitmap* bitmap,[In, Optional] const D2D1_RECT_U* srcRect) + + + + Copies the specified region from the specified bitmap into the current bitmap. + + + This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion, and will fail if the bitmap formats do not match. Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to {{EndDraw}} or {{Flush}}. + + The bitmap to copy from. + The area of bitmap to copy. + In the current bitmap, the upper-left corner of the area to which the region specified by srcRect is copied. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Bitmap::CopyFromBitmap([In, Optional] const D2D1_POINT_2U* destPoint,[In] ID2D1Bitmap* bitmap,[In, Optional] const D2D1_RECT_U* srcRect) + + + + Copies the specified region from memory into the current bitmap. + + + This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion; the two bitmap formats should match. Passing this method invalid input, such as an invalid destination rectangle, can produce unpredictable results, such as a distorted image or device failure. Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to {{EndDraw}} or {{Flush}}. + + The data to copy. + The stride, or pitch, of the source bitmap stored in srcData. The stride is the byte count of a scanline (one row of pixels in memory). The stride can be computed from the following formula: pixel width * bytes per pixel + memory padding. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Bitmap::CopyFromMemory([In, Optional] const D2D1_RECT_U* dstRect,[In] const void* srcData,[None] int pitch) + + + + Copies the specified region from memory into the current bitmap. + + + This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion; the two bitmap formats should match. Passing this method invalid input, such as an invalid destination rectangle, can produce unpredictable results, such as a distorted image or device failure. Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to {{EndDraw}} or {{Flush}}. + + The data to copy. + The stride, or pitch, of the source bitmap stored in srcData. The stride is the byte count of a scanline (one row of pixels in memory). The stride can be computed from the following formula: pixel width * bytes per pixel + memory padding. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Bitmap::CopyFromMemory([In, Optional] const D2D1_RECT_U* dstRect,[In] const void* srcData,[None] int pitch) + + + + Copies the specified region from memory into the current bitmap. + + + This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion; the two bitmap formats should match. Passing this method invalid input, such as an invalid destination rectangle, can produce unpredictable results, such as a distorted image or device failure. Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to {{EndDraw}} or {{Flush}}. + + The data to copy. + The stride, or pitch, of the source bitmap stored in srcData. The stride is the byte count of a scanline (one row of pixels in memory). The stride can be computed from the following formula: pixel width * bytes per pixel + memory padding. + In the current bitmap, the upper-left corner of the area to which the region specified by srcRect is copied. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Bitmap::CopyFromMemory([In, Optional] const D2D1_RECT_U* dstRect,[In] const void* srcData,[None] int pitch) + + + + Copies the specified region from memory into the current bitmap. + + + This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion; the two bitmap formats should match. Passing this method invalid input, such as an invalid destination rectangle, can produce unpredictable results, such as a distorted image or device failure. Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to {{EndDraw}} or {{Flush}}. + + The data to copy. + The stride, or pitch, of the source bitmap stored in srcData. The stride is the byte count of a scanline (one row of pixels in memory). The stride can be computed from the following formula: pixel width * bytes per pixel + memory padding. + In the current bitmap, the upper-left corner of the area to which the region specified by srcRect is copied. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Bitmap::CopyFromMemory([In, Optional] const D2D1_RECT_U* dstRect,[In] const void* srcData,[None] int pitch) + + + + Copies the specified region from the specified render target into the current bitmap. + + + This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion, and will fail if the bitmap formats do not match. Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to {{EndDraw}} or {{Flush}}. All clips and layers must be popped off of the render target before calling this method. The method returns {{D2DERR_RENDER_TARGET_HAS_LAYER_OR_CLIPRECT}} if any clips or layers are currently applied to the render target. + + The render target that contains the region to copy. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Bitmap::CopyFromRenderTarget([In, Optional] const D2D1_POINT_2U* destPoint,[In] ID2D1RenderTarget* renderTarget,[In, Optional] const D2D1_RECT_U* srcRect) + + + + Copies the specified region from the specified render target into the current bitmap. + + + This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion, and will fail if the bitmap formats do not match. Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to {{EndDraw}} or {{Flush}}. All clips and layers must be popped off of the render target before calling this method. The method returns {{D2DERR_RENDER_TARGET_HAS_LAYER_OR_CLIPRECT}} if any clips or layers are currently applied to the render target. + + The render target that contains the region to copy. + In the current bitmap, the upper-left corner of the area to which the region specified by srcRect is copied. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Bitmap::CopyFromRenderTarget([In, Optional] const D2D1_POINT_2U* destPoint,[In] ID2D1RenderTarget* renderTarget,[In, Optional] const D2D1_RECT_U* srcRect) + + + + Copies the specified region from the specified render target into the current bitmap. + + + This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion, and will fail if the bitmap formats do not match. Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to {{EndDraw}} or {{Flush}}. All clips and layers must be popped off of the render target before calling this method. The method returns {{D2DERR_RENDER_TARGET_HAS_LAYER_OR_CLIPRECT}} if any clips or layers are currently applied to the render target. + + The render target that contains the region to copy. + In the current bitmap, the upper-left corner of the area to which the region specified by srcRect is copied. + The area of renderTarget to copy. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Bitmap::CopyFromRenderTarget([In, Optional] const D2D1_POINT_2U* destPoint,[In] ID2D1RenderTarget* renderTarget,[In, Optional] const D2D1_RECT_U* srcRect) + + + + Copies the specified region from a stream into the current bitmap. + + + This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion; the two bitmap formats should match. Passing this method invalid input, such as an invalid destination rectangle, can produce unpredictable results, such as a distorted image or device failure. Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to {{EndDraw}} or {{Flush}}. + + The stream to copy the data from. + Length in bytes of the data to copy from the stream. + The stride, or pitch, of the source bitmap stored in srcData. The stride is the byte count of a scanline (one row of pixels in memory). The stride can be computed from the following formula: pixel width * bytes per pixel + memory padding. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Bitmap::CopyFromMemory([In, Optional] const D2D1_RECT_U* dstRect,[In] const void* srcData,[None] int pitch) + + + + Copies the specified region from a stream into the current bitmap. + + + This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion; the two bitmap formats should match. Passing this method invalid input, such as an invalid destination rectangle, can produce unpredictable results, such as a distorted image or device failure. Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to {{EndDraw}} or {{Flush}}. + + The stream to copy the data from. + Length in bytes of the data to copy from the stream. + The stride, or pitch, of the source bitmap stored in srcData. The stride is the byte count of a scanline (one row of pixels in memory). The stride can be computed from the following formula: pixel width * bytes per pixel + memory padding. + In the current bitmap, the upper-left corner of the area to which the region specified by srcRect is copied. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Bitmap::CopyFromMemory([In, Optional] const D2D1_RECT_U* dstRect,[In] const void* srcData,[None] int pitch) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Returns the size, in device-independent pixels (DIPs), of the bitmap. + + + A DIP is 1/96?of an inch. To retrieve the size in device pixels, use the method. + + The size, in DIPs, of the bitmap. + D2D1_SIZE_F ID2D1Bitmap::GetSize() + + + + Returns the size, in device-dependent units (pixels), of the bitmap. + + The size, in pixels, of the bitmap. + D2D1_SIZE_U ID2D1Bitmap::GetPixelSize() + + + + Retrieves the pixel format and alpha mode of the bitmap. + + The pixel format and alpha mode of the bitmap. + D2D1_PIXEL_FORMAT ID2D1Bitmap::GetPixelFormat() + + + + Return the dots per inch (DPI) of the bitmap. + + The horizontal DPI of the image. You must allocate storage for this parameter. + The vertical DPI of the image. You must allocate storage for this parameter. + void ID2D1Bitmap::GetDpi([Out] float* dpiX,[Out] float* dpiY) + + + + Copies the specified region from the specified bitmap into the current bitmap. + + + This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion, and will fail if the bitmap formats do not match. Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to {{EndDraw}} or {{Flush}}. + + In the current bitmap, the upper-left corner of the area to which the region specified by srcRect is copied. + The bitmap to copy from. + The area of bitmap to copy. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Bitmap::CopyFromBitmap([In, Optional] const D2D1_POINT_2U* destPoint,[In] ID2D1Bitmap* bitmap,[In, Optional] const D2D1_RECT_U* srcRect) + + + + Copies the specified region from the specified render target into the current bitmap. + + + This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion, and will fail if the bitmap formats do not match. Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to {{EndDraw}} or {{Flush}}. All clips and layers must be popped off of the render target before calling this method. The method returns {{D2DERR_RENDER_TARGET_HAS_LAYER_OR_CLIPRECT}} if any clips or layers are currently applied to the render target. + + In the current bitmap, the upper-left corner of the area to which the region specified by srcRect is copied. + The render target that contains the region to copy. + The area of renderTarget to copy. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Bitmap::CopyFromRenderTarget([In, Optional] const D2D1_POINT_2U* destPoint,[In] ID2D1RenderTarget* renderTarget,[In, Optional] const D2D1_RECT_U* srcRect) + + + + Copies the specified region from memory into the current bitmap. + + + This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion; the two bitmap formats should match. Passing this method invalid input, such as an invalid destination rectangle, can produce unpredictable results, such as a distorted image or device failure. Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to {{EndDraw}} or {{Flush}}. + + In the current bitmap, the upper-left corner of the area to which the region specified by srcRect is copied. + The data to copy. + The stride, or pitch, of the source bitmap stored in srcData. The stride is the byte count of a scanline (one row of pixels in memory). The stride can be computed from the following formula: pixel width * bytes per pixel + memory padding. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Bitmap::CopyFromMemory([In, Optional] const D2D1_RECT_U* dstRect,[In] const void* srcData,[None] int pitch) + + + + Return the dots per inch (DPI) of the bitmap. + + The dots per inch (DPI) of the bitma. + + + + Returns the size, in device-independent pixels (DIPs), of the bitmap. + + + A DIP is 1/96?of an inch. To retrieve the size in device pixels, use the method. + + D2D1_SIZE_F ID2D1Bitmap::GetSize() + + + + Returns the size, in device-dependent units (pixels), of the bitmap. + + D2D1_SIZE_U ID2D1Bitmap::GetPixelSize() + + + + Retrieves the pixel format and alpha mode of the bitmap. + + D2D1_PIXEL_FORMAT ID2D1Bitmap::GetPixelFormat() + + + + Paints an area with a bitmap. + + ID2D1BitmapBrush + + + + Defines an object that paints an area. Interfaces that derive from ID2D1Brush describe how the area is painted. + + ID2D1Brush + + + + Initializes a new instance of the class. + + The native pointer. + + + + Sets the degree of opacity of this brush. + + A value between zero and 1 that indicates the opacity of the brush. This value is a constant multiplier that linearly scales the alpha value of all pixels filled by the brush. The opacity values are clamped in the range 0?1 before they are multipled together. + void ID2D1Brush::SetOpacity([None] float opacity) + + + + Sets the transformation applied to the brush. + + The transformation to apply to this brush. + void ID2D1Brush::SetTransform([In] const D2D1_MATRIX_3X2_F* transform) + + + + Gets the degree of opacity of this brush. + + FLOATA value between zero and 1 that indicates the opacity of the brush. This value is a constant multiplier that linearly scales the alpha value of all pixels filled by the brush. The opacity values are clamped in the range 0?1 before they are multipled together. + float ID2D1Brush::GetOpacity() + + + + Gets the transform applied to this brush. + + + When the brush transform is the identity matrix, the brush appears in the same coordinate space as the render target in which it is drawn. + + The transform applied to this brush. + void ID2D1Brush::GetTransform([Out] D2D1_MATRIX_3X2_F* transform) + + + + Gets the degree of opacity of this brush. + + float ID2D1Brush::GetOpacity() + + + + Gets the transform applied to this brush. + + + When the brush transform is the identity matrix, the brush appears in the same coordinate space as the render target in which it is drawn. + + void ID2D1Brush::GetTransform([Out] D2D1_MATRIX_3X2_F* transform) + + + + Creates an from the specified bitmap. + + an instance of + The bitmap contents of the new brush. + HRESULT CreateBitmapBrush([In] ID2D1Bitmap* bitmap,[In, Optional] const D2D1_BITMAP_BRUSH_PROPERTIES* bitmapBrushProperties,[In, Optional] const D2D1_BRUSH_PROPERTIES* brushProperties,[Out] ID2D1BitmapBrush** bitmapBrush) + + + + Creates an from the specified bitmap. + + an instance of + The bitmap contents of the new brush. + The extend modes and interpolation mode of the new brush, or NULL. If this parameter is NULL, the brush defaults to the horizontal and vertical extend modes and the interpolation mode. + HRESULT CreateBitmapBrush([In] ID2D1Bitmap* bitmap,[In, Optional] const D2D1_BITMAP_BRUSH_PROPERTIES* bitmapBrushProperties,[In, Optional] const D2D1_BRUSH_PROPERTIES* brushProperties,[Out] ID2D1BitmapBrush** bitmapBrush) + + + + Creates an from the specified bitmap. + + an instance of + The bitmap contents of the new brush. + The opacity and transform of the new brush, or NULL. If this parameter is NULL, the brush defaults to an opacity of 1.0f and its transform is the identity matrix. + HRESULT CreateBitmapBrush([In] ID2D1Bitmap* bitmap,[In, Optional] const D2D1_BITMAP_BRUSH_PROPERTIES* bitmapBrushProperties,[In, Optional] const D2D1_BRUSH_PROPERTIES* brushProperties,[Out] ID2D1BitmapBrush** bitmapBrush) + + + + Creates an from the specified bitmap. + + an instance of + The bitmap contents of the new brush. + The extend modes and interpolation mode of the new brush, or NULL. If this parameter is NULL, the brush defaults to the horizontal and vertical extend modes and the interpolation mode. + The opacity and transform of the new brush, or NULL. If this parameter is NULL, the brush defaults to an opacity of 1.0f and its transform is the identity matrix. + HRESULT CreateBitmapBrush([In] ID2D1Bitmap* bitmap,[In, Optional] const D2D1_BITMAP_BRUSH_PROPERTIES* bitmapBrushProperties,[In, Optional] const D2D1_BRUSH_PROPERTIES* brushProperties,[Out] ID2D1BitmapBrush** bitmapBrush) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Specifies how the brush horizontally tiles those areas that extend past its bitmap. + + + Sometimes, the bitmap for a bitmap brush doesn't completely fill the area being painted. When this happens, Direct2D uses the brush's horizontal (SetExtendModeX) and vertical ({{SetExtendModeY}}) extend mode settings to determine how to fill the remaining area. The following illustration shows the results from every possible combination of the extend modes for an : (CLAMP), D2D1_EXTEND_MODE_WRAP (WRAP), and D2D1_EXTEND_MIRROR (MIRROR). ? Illustration of a bitmap and the resulting images from various extend modes ? + + A value that specifies how the brush horizontally tiles those areas that extend past its bitmap. + void ID2D1BitmapBrush::SetExtendModeX([None] D2D1_EXTEND_MODE extendModeX) + + + + Specifies how the brush vertically tiles those areas that extend past its bitmap. + + + Sometimes, the bitmap for a bitmap brush doesn't completely fill the area being painted. When this happens, Direct2D uses the brush's horizontal ({{SetExtendModeX}}) and vertical (SetExtendModeY) extend mode settings to determine how to fill the remaining area. The following illustration shows the results from every possible combination of the extend modes for an : (CLAMP), D2D1_EXTEND_MODE_WRAP (WRAP), and D2D1_EXTEND_MIRROR (MIRROR). ? Illustration of a bitmap and the resulting images from various extend modes ? + + A value that specifies how the brush vertically tiles those areas that extend past its bitmap. + void ID2D1BitmapBrush::SetExtendModeY([None] D2D1_EXTEND_MODE extendModeY) + + + + Specifies the interpolation mode used when the brush bitmap is scaled or rotated. + + + This method sets the interpolation mode for a bitmap, which is an enum value that is specified in the enumeration type. D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR represents nearest neighbor filtering. It looks up the nearest bitmap pixel to the current rendering pixel and chooses its exact color. D2D1_BITMAP_INTERPOLATION_MODE_LINEAR represents linear filtering, and interpolates a color from the four nearest bitmap pixels. The interpolation mode of a bitmap also affects subpixel translations. In a subpixel translation, bilinear interpolation positions the bitmap more precisely to the application requests, but blurs the bitmap in the process. + + The interpolation mode used when the brush bitmap is scaled or rotated. + void ID2D1BitmapBrush::SetInterpolationMode([None] D2D1_BITMAP_INTERPOLATION_MODE interpolationMode) + + + + Specifies the bitmap source that this brush uses to paint. + + + This method specifies the bitmap source that this brush uses to paint. The bitmap is not resized or rescaled automatically to fit the geometry that it fills. The bitmap stays at its native size. To resize or translate the bitmap, use the {{SetTransform}} method to apply a transform to the brush. The native size of a bitmap is the width and height in bitmap pixels, divided by the bitmap DPI. This native size forms the base tile of the brush. To tile a subregion of the bitmap, you must generate a new bitmap containing this subregion and use SetBitmap to apply it to the brush. + + + The bitmap source used by the brush. + void ID2D1BitmapBrush::SetBitmap([In] ID2D1Bitmap* bitmap) + + + + Gets the method by which the brush horizontally tiles those areas that extend past its bitmap. + + + Like all brushes, defines an infinite plane of content. Because bitmaps are finite, it relies on an extend mode to determine how the plane is filled horizontally and vertically. + + A value that specifies how the brush horizontally tiles those areas that extend past its bitmap. + D2D1_EXTEND_MODE ID2D1BitmapBrush::GetExtendModeX() + + + + Gets the method by which the brush vertically tiles those areas that extend past its bitmap. + + + Like all brushes, defines an infinite plane of content. Because bitmaps are finite, it relies on an extend mode to determine how the plane is filled horizontally and vertically. + + A value that specifies how the brush vertically tiles those areas that extend past its bitmap. + D2D1_EXTEND_MODE ID2D1BitmapBrush::GetExtendModeY() + + + + Gets the interpolation method used when the brush bitmap is scaled or rotated. + + + This method gets the interpolation mode of a bitmap, which is specified by the enumeration type. D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR represents nearest neighbor filtering. It looks up the bitmap pixel nearest to the current rendering pixel and chooses its exact color. D2D1_BITMAP_INTERPOLATION_MODE_LINEAR represents linear filtering, and interpolates a color from the four nearest bitmap pixels. The interpolation mode of a bitmap also affects subpixel translations. In a subpixel translation, linear interpolation positions the bitmap more precisely to the application request, but blurs the bitmap in the process. + + The interpolation method used when the brush bitmap is scaled or rotated. + D2D1_BITMAP_INTERPOLATION_MODE ID2D1BitmapBrush::GetInterpolationMode() + + + + Gets the bitmap source that this brush uses to paint. + + When this method returns, contains the address to a reference to the bitmap with which this brush paints. + void ID2D1BitmapBrush::GetBitmap([Out] ID2D1Bitmap** bitmap) + + + + Gets the method by which the brush horizontally tiles those areas that extend past its bitmap. + + + Like all brushes, defines an infinite plane of content. Because bitmaps are finite, it relies on an extend mode to determine how the plane is filled horizontally and vertically. + + D2D1_EXTEND_MODE ID2D1BitmapBrush::GetExtendModeX() + + + + Gets the method by which the brush vertically tiles those areas that extend past its bitmap. + + + Like all brushes, defines an infinite plane of content. Because bitmaps are finite, it relies on an extend mode to determine how the plane is filled horizontally and vertically. + + D2D1_EXTEND_MODE ID2D1BitmapBrush::GetExtendModeY() + + + + Gets the interpolation method used when the brush bitmap is scaled or rotated. + + + This method gets the interpolation mode of a bitmap, which is specified by the enumeration type. D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR represents nearest neighbor filtering. It looks up the bitmap pixel nearest to the current rendering pixel and chooses its exact color. D2D1_BITMAP_INTERPOLATION_MODE_LINEAR represents linear filtering, and interpolates a color from the four nearest bitmap pixels. The interpolation mode of a bitmap also affects subpixel translations. In a subpixel translation, linear interpolation positions the bitmap more precisely to the application request, but blurs the bitmap in the process. + + D2D1_BITMAP_INTERPOLATION_MODE ID2D1BitmapBrush::GetInterpolationMode() + + + + Gets the bitmap source that this brush uses to paint. + + void ID2D1BitmapBrush::GetBitmap([Out] ID2D1Bitmap** bitmap) + + + + Describes the pixel format and dpi of a bitmap. + + D2D1_BITMAP_PROPERTIES + + + + Initializes a new instance of the struct. + + The pixel format. + + + + Initializes a new instance of the struct. + + The pixel format. + The dpi X. + The dpi Y. + + + + The bitmap's pixel format and alpha mode. + + D2D1_PIXEL_FORMAT pixelFormat + + + + The horizontal dpi of the bitmap. + + float dpiX + + + + The vertical dpi of the bitmap. + + float dpiY + + + + Renders to an intermediate texture created by the {{CreateCompatibleRenderTarget}} method. + + ID2D1BitmapRenderTarget + + + + Represents an object that can receive drawing commands. Interfaces that inherit from ID2D1RenderTarget render the drawing commands they receive in different ways. + + ID2D1RenderTarget + + + + Default stroke width used for all methods that are not explicitly using it. Default is set to 1.0f. + + + + + Initializes a new instance of the class. + + The native pointer. + + + + Creates an uninitialized Direct2D bitmap. + + The dimension of the bitmap to create in pixels. + The pixel format and dots per inch (DPI) of the bitmap to create. + When this method returns, contains a reference to a reference to the new bitmap. This parameter is passed uninitialized. + No documentation. + No documentation. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1RenderTarget::CreateBitmap([None] D2D1_SIZE_U size,[In, Optional] const void* srcData,[None] int pitch,[In] const D2D1_BITMAP_PROPERTIES* bitmapProperties,[Out] ID2D1Bitmap** bitmap) + + + + Creates an whose data is shared with another resource. + + + The CreateSharedBitmap method is useful for efficiently reusing bitmap data and can also be used to provide interoperability with Direct3D. Sharing an ID2D1Bitmap By passing an created by a render target that is resource-compatible, you can share a bitmap with that render target; both the original ID2D1Bitmap and the new ID2D1Bitmap created by this method will point to the same bitmap data. For more information about when render target resources can be shared, see the Sharing Render Target Resources section of the {{Resources Overview}}. You may also use this method to reinterpret the data of an existing bitmap and specify a new DPI or alpha mode. For example, in the case of a bitmap atlas, an may contain multiple sub-images, each of which should be rendered with a different (D2D1_ALPHA_MODE_PREMULTIPLIED or D2D1_ALPHA_MODE_IGNORE). You could use the CreateSharedBitmap method to reinterpret the bitmap using the desired alpha mode without having to load a separate copy of the bitmap into memory. Sharing an IDXGISurface When using a DXGI surface render target (an object created by the {{CreateDxgiSurfaceRenderTarget}} method), you can pass an surface to the CreateSharedBitmap method to share video memory with Direct3D and manipulate Direct3D content as an . As described in the {{Resources Overview}}, the render target and the must be using the same Direct3D device. Note also that the must use one of the supported pixel formats and alpha modes described in {{Supported Pixel Formats and Alpha Modes}}. For more information about interoperability with Direct3D, see the {{Direct2D and Direct3D Interoperability Overview}}. Sharing an IWICBitmapLock An {{IWICBitmapLock}} stores the content of a WIC bitmap and shields it from simultaneous accesses. By passing an IWICBitmapLock to the CreateSharedBitmap method, you can create an that points to the bitmap data already stored in the IWICBitmapLock. To use an {{IWICBitmapLock}} with the CreateSharedBitmap method, the render target must use software rendering. To force a render target to use software rendering, set to the type field of the structure that you use to create the render target. To check whether an existing render target uses software rendering, use the {{IsSupported}} method. + + The interface ID of the object supplying the source data. + An , , or an {{IWICBitmapLock}} that contains the data to share with the new ID2D1Bitmap. For more information, see the Remarks section. + The pixel format and DPI of the bitmap to create . The portion of the pixel format must match the of data or the method will fail, but the alpha modes don't have to match. To prevent a mismatch, you can pass NULL or the value obtained from the {{D2D1::PixelFormat}} helper function. The DPI settings do not have to match those of data. If both dpiX and dpiY are 0.0f, the default DPI, 96, is used. + When this method returns, contains the address of a reference to the new bitmap. This parameter is passed uninitialized. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1RenderTarget::CreateSharedBitmap([In] GUID* riid,[In] void* data,[In, Optional] const D2D1_BITMAP_PROPERTIES* bitmapProperties,[Out] ID2D1Bitmap** bitmap) + + + + Creates an from the specified bitmap. + + The bitmap contents of the new brush. + The extend modes and interpolation mode of the new brush, or NULL. If this parameter is NULL, the brush defaults to the horizontal and vertical extend modes and the interpolation mode. + The opacity and transform of the new brush, or NULL. If this parameter is NULL, the brush defaults to an opacity of 1.0f and its transform is the identity matrix. + When this method returns, contains a reference to a reference to the new brush. This parameter is passed uninitialized. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1RenderTarget::CreateBitmapBrush([In] ID2D1Bitmap* bitmap,[In, Optional] const D2D1_BITMAP_BRUSH_PROPERTIES* bitmapBrushProperties,[In, Optional] const D2D1_BRUSH_PROPERTIES* brushProperties,[Out] ID2D1BitmapBrush** bitmapBrush) + + + + Creates a new that has the specified color and opacity. + + The red, green, blue, and alpha values of the brush's color. + The base opacity of the brush. + When this method returns, contains the address of a reference to the new brush. This parameter is passed uninitialized. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1RenderTarget::CreateSolidColorBrush([In] const D2D1_COLOR_F* color,[In, Optional] const D2D1_BRUSH_PROPERTIES* brushProperties,[Out] ID2D1SolidColorBrush** solidColorBrush) + + + + Creates an from the specified gradient stops, color interpolation gamma, and extend mode. + + A reference to an array of D2D1_GRADIENT_STOP structures. + A value greater than or equal to 1 that specifies the number of gradient stops in the gradientStops array. + The space in which color interpolation between the gradient stops is performed. + The behavior of the gradient outside the [0,1] normalized range. + When this method returns, contains a reference to a reference to the new gradient stop collection. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1RenderTarget::CreateGradientStopCollection([In, Buffer] const D2D1_GRADIENT_STOP* gradientStops,[None] int gradientStopsCount,[None] D2D1_GAMMA colorInterpolationGamma,[None] D2D1_EXTEND_MODE extendMode,[Out] ID2D1GradientStopCollection** gradientStopCollection) + + + + Creates an that contains the specified gradient stops and has the specified transform and base opacity. + + The start and end points of the gradient. + The transform and base opacity of the new brush, or NULL. If this value is NULL, the brush defaults to a base opacity of 1.0f and the identity matrix as its transformation. + A collection of structures that describe the colors in the brush's gradient and their locations along the gradient line. + When this method returns, contains the address of a reference to the new brush. This paramater is passed uninitialized. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1RenderTarget::CreateLinearGradientBrush([In] const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES* linearGradientBrushProperties,[In, Optional] const D2D1_BRUSH_PROPERTIES* brushProperties,[In] ID2D1GradientStopCollection* gradientStopCollection,[Out] ID2D1LinearGradientBrush** linearGradientBrush) + + + + Creates an that contains the specified gradient stops and has the specified transform and base opacity. + + The center, gradient origin offset, and x-radius and y-radius of the brush's gradient. + The transform and base opacity of the new brush, or NULL. If this value is NULL, the brush defaults to a base opacity of 1.0f and the identity matrix as its transformation. + A collection of structures that describe the colors in the brush's gradient and their locations along the gradient. + When this method returns, contains a reference to a reference to the new brush. This paramater is passed uninitialized. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1RenderTarget::CreateRadialGradientBrush([In] const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES* radialGradientBrushProperties,[In, Optional] const D2D1_BRUSH_PROPERTIES* brushProperties,[In] ID2D1GradientStopCollection* gradientStopCollection,[Out] ID2D1RadialGradientBrush** radialGradientBrush) + + + + Creates a bitmap render target for use during intermediate offscreen drawing that is compatible with the current render target. + + + The pixel size and DPI of the new render target can be altered by specifying values for desiredSize or desiredPixelSize: If desiredSize is specified but desiredPixelSize is not, the pixel size is computed from the desired size using the parent target DPI. If the desiredSize maps to a integer-pixel size, the DPI of the compatible render target is the same as the DPI of the parent target. If desiredSize maps to a fractional-pixel size, the pixel size is rounded up to the nearest integer and the DPI for the compatible render target is slightly higher than the DPI of the parent render target. In all cases, the coordinate (desiredSize.width, desiredSize.height) maps to the lower-right corner of the compatible render target. If the desiredPixelSize is specified and desiredSize is not, the DPI of the new render target is the same as the original render target. If both desiredSize and desiredPixelSize are specified, the DPI of the new render target is computed to account for the difference in scale. If neither desiredSize nor desiredPixelSize is specified, the new render target size and DPI match the original render target. + + The desired size of the new render target in device-independent pixels if it should be different from the original render target. For more information, see the Remarks section. + The desired size of the new render target in pixels if it should be different from the original render target. For more information, see the Remarks section. + The desired pixel format and alpha mode of the new render target. If the pixel format is set to DXGI_FORMAT_UNKNOWN, the new render target uses the same pixel format as the original render target. If the alpha mode is , the alpha mode of the new render target defaults to D2D1_ALPHA_MODE_PREMULTIPLIED. For information about supported pixel formats, see {{Supported Pixel Formats and Alpha Modes}}. + A value that specifies whether the new render target must be compatible with GDI. + When this method returns, contains a reference to a reference to a new bitmap render target. This parameter is passed uninitialized. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1RenderTarget::CreateCompatibleRenderTarget([In, Optional] const D2D1_SIZE_F* desiredSize,[In, Optional] const D2D1_SIZE_U* desiredPixelSize,[In, Optional] const D2D1_PIXEL_FORMAT* desiredFormat,[None] D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options,[Out] ID2D1BitmapRenderTarget** bitmapRenderTarget) + + + + Creates a layer resource that can be used with this render target and its compatible render targets. The new layer has the specified initial size. + + + Regardless of whether a size is initially specified, the layer automatically resizes as needed. + + If (0, 0) is specified, no backing store is created behind the layer resource. The layer resource is allocated to the minimum size when {{PushLayer}} is called. + When the method returns, contains a reference to a reference to the new layer. This parameter is passed uninitialized. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1RenderTarget::CreateLayer([In, Optional] const D2D1_SIZE_F* size,[Out] ID2D1Layer** layer) + + + + Create a mesh that uses triangles to describe a shape. + + + To populate a mesh, use its {{Open}} method to obtain an . To draw the mesh, use the render target's {{FillMesh}} method. + + When this method returns, contains a reference to a reference to the new mesh. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1RenderTarget::CreateMesh([Out] ID2D1Mesh** mesh) + + + + Draws a line between the specified points using the specified stroke style. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as DrawLine) failed, check the result returned by the or methods. + + The start point of the line, in device-independent pixels. + The end point of the line, in device-independent pixels. + The brush used to paint the line's stroke. + A value greater than or equal to 0.0f that specifies the width of the stroke. If this parameter isn't specified, it defaults to 1.0f. The stroke is centered on the line. + The style of stroke to paint, or NULL to paint a solid line. + void ID2D1RenderTarget::DrawLine([None] D2D1_POINT_2F point0,[None] D2D1_POINT_2F point1,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Draws the outline of a rectangle that has the specified dimensions and stroke style. + + + When this method fails, it does not return an error code. To determine whether a drawing method (such as {{DrawRectangle}}) failed, check the result returned by the or method. + + The dimensions of the rectangle to draw, in device-independent pixels. + The brush used to paint the rectangle's stroke. + A value greater than or equal to 0.0f that specifies the width of the rectangle's stroke. The stroke is centered on the rectangle's outline. + The style of stroke to paint, or NULL to paint a solid stroke. + void ID2D1RenderTarget::DrawRectangle([In] const D2D1_RECT_F* rect,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Paints the interior of the specified rectangle. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{FillRectangle}}) failed, check the result returned by the or methods. + + The dimension of the rectangle to paint, in device-independent pixels. + The brush used to paint the rectangle's interior. + void ID2D1RenderTarget::FillRectangle([In] const D2D1_RECT_F* rect,[In] ID2D1Brush* brush) + + + + Draws the outline of the specified rounded rectangle using the specified stroke style. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{DrawRoundedRectangle}}) failed, check the result returned by the or methods. + + The dimensions of the rounded rectangle to draw, in device-independent pixels. + The brush used to paint the rounded rectangle's outline. + The width of the rounded rectangle's stroke. The stroke is centered on the rounded rectangle's outline. The default value is 1.0f. + The style of the rounded rectangle's stroke, or NULL to paint a solid stroke. The default value is NULL. + void ID2D1RenderTarget::DrawRoundedRectangle([In] const D2D1_ROUNDED_RECT* roundedRect,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Paints the interior of the specified rounded rectangle. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{FillRoundedRectangle}}) failed, check the result returned by the or methods. + + The dimensions of the rounded rectangle to paint, in device-independent pixels. + The brush used to paint the interior of the rounded rectangle. + void ID2D1RenderTarget::FillRoundedRectangle([In] const D2D1_ROUNDED_RECT* roundedRect,[In] ID2D1Brush* brush) + + + + Draws the outline of the specified ellipse using the specified stroke style. + + + The {{DrawEllipse}} method doesn't return an error code if it fails. To determine whether a drawing operation (such as DrawEllipse) failed, check the result returned by the or methods. + + The position and radius of the ellipse to draw, in device-independent pixels. + The brush used to paint the ellipse's outline. + The thickness of the ellipse's stroke. The stroke is centered on the ellipse's outline. + The style of stroke to apply to the ellipse's outline, or NULL to paint a solid stroke. + void ID2D1RenderTarget::DrawEllipse([In] const D2D1_ELLIPSE* ellipse,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Paints the interior of the specified ellipse. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{FillEllipse}}) failed, check the result returned by the or methods. + + The position and radius, in device-independent pixels, of the ellipse to paint. + The brush used to paint the interior of the ellipse. + void ID2D1RenderTarget::FillEllipse([In] const D2D1_ELLIPSE* ellipse,[In] ID2D1Brush* brush) + + + + Draws the outline of the specified geometry using the specified stroke style. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as DrawGeometry) failed, check the result returned by the or methods. + + The geometry to draw. + The brush used to paint the geometry's stroke. + The thickness of the geometry's stroke. The stroke is centered on the geometry's outline. + The style of stroke to apply to the geometry's outline, or NULL to paint a solid stroke. + void ID2D1RenderTarget::DrawGeometry([In] ID2D1Geometry* geometry,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Paints the interior of the specified geometry. + + + If the opacityBrush parameter is not NULL, the alpha value of each pixel of the mapped opacityBrush is used to determine the resulting opacity of each corresponding pixel of the geometry. Only the alpha value of each color in the brush is used for this processing; all other color information is ignored. The alpha value specified by the brush is multiplied by the alpha value of the geometry after the geometry has been painted by brush. + When this method fails, it does not return an error code. To determine whether a drawing operation (such as FillGeometry) failed, check the result returned by the or method. + + The geometry to paint. + The brush used to paint the geometry's interior. + The opacity mask to apply to the geometry;NULL for no opacity mask. If an opacity mask (the opacityBrush parameter) is specified, brush must be an that has its x- and y-extend modes set to . For more information, see the Remarks section. + void ID2D1RenderTarget::FillGeometry([In] ID2D1Geometry* geometry,[In] ID2D1Brush* brush,[In, Optional] ID2D1Brush* opacityBrush) + + + + Paints the interior of the specified mesh. + + + The current antialias mode of the render target must be when FillMesh is called. To change the render target's antialias mode, use the {{SetAntialiasMode}} method. FillMesh does not expect a particular winding order for the triangles in the ; both clockwise and counter-clockwise will work. This method doesn't return an error code if it fails. To determine whether a drawing operation (such as FillMesh) failed, check the result returned by the or methods. + + The mesh to paint. + The brush used to paint the mesh. + void ID2D1RenderTarget::FillMesh([In] ID2D1Mesh* mesh,[In] ID2D1Brush* brush) + + + + Applies the opacity mask described by the specified bitmap to a brush and uses that brush to paint a region of the render target. + + + For this method to work properly, the render target must be using the antialiasing mode. You can set the antialiasing mode by calling the method. This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{FillOpacityMask}}) failed, check the result returned by the or methods. + + The opacity mask to apply to the brush. The alpha value of each pixel in the region specified by sourceRectangle is multiplied with the alpha value of the brush after the brush has been mapped to the area defined by destinationRectangle. + The brush used to paint the region of the render target specified by destinationRectangle. + The type of content the opacity mask contains. The value is used to determine the color space in which the opacity mask is blended. + The region of the render target to paint, in device-independent pixels, or NULL. If NULL is specified, the brush paints a rectangle the same size as sourceRectangle, but positioned on the origin. If sourceRectangle isn't specified, the brush paints a rectangle the same size as the opacityMask bitmap and positioned on the origin. + The region of the bitmap to use as the opacity mask, in device-independent pixels, or NULL. If NULL is specified, the entire bitmap is used. + void ID2D1RenderTarget::FillOpacityMask([In] ID2D1Bitmap* opacityMask,[In] ID2D1Brush* brush,[None] D2D1_OPACITY_MASK_CONTENT content,[In, Optional] const D2D1_RECT_F* destinationRectangle,[In, Optional] const D2D1_RECT_F* sourceRectangle) + + + + Draws the specified bitmap after scaling it to the size of the specified rectangle. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{DrawBitmap}}) failed, check the result returned by the or methods. + + The bitmap to render. + The size and position, in device-independent pixels in the render target's coordinate space, of the area to which the bitmap is drawn; NULL to draw the selected portion of the bitmap at the origin of the render target. If the rectangle is specified but not well-ordered, nothing is drawn, but the render target does not enter an error state. + A value between 0.0f and 1.0f, inclusive, that specifies an opacity value to apply to the bitmap; this value is multiplied against the alpha values of the bitmap's contents. The default value is 1.0f. + The interpolation mode to use if the bitmap is scaled or rotated by the drawing operation. The default value is . + The size and position, in device-independent pixels in the bitmap's coordinate space, of the area within the bitmap to be drawn; NULL to draw the entire bitmap. + void ID2D1RenderTarget::DrawBitmap([In] ID2D1Bitmap* bitmap,[In, Optional] const D2D1_RECT_F* destinationRectangle,[None] float opacity,[None] D2D1_BITMAP_INTERPOLATION_MODE interpolationMode,[In, Optional] const D2D1_RECT_F* sourceRectangle) + + + + Draws the specified text using the format information provided by an object. + + + To create an object, create an and call its {{CreateTextFormat}} method. This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{DrawText}}) failed, check the result returned by the or methods. + + A reference to an array of Unicode characters to draw. + The number of characters in string. + An object that describes formatting details of the text to draw, such as the font, the font size, and flow direction. + The size and position of the area in which the text is drawn. + The brush used to paint the text. + A value that indicates whether the text should be snapped to pixel boundaries and whether the text should be clipped to the layout rectangle. The default value is , which indicates that text should be snapped to pixel boundaries and it should not be clipped to the layout rectangle. + A value that indicates how glyph metrics are used to measure text when it is formatted. The default value is DWRITE_MEASURING_MODE_NATURAL. + void ID2D1RenderTarget::DrawTextA([In, Buffer] const wchar_t* string,[None] int stringLength,[In] IDWriteTextFormat* textFormat,[In] const D2D1_RECT_F* layoutRect,[In] ID2D1Brush* defaultForegroundBrush,[None] D2D1_DRAW_TEXT_OPTIONS options,[None] DWRITE_MEASURING_MODE measuringMode) + + + + Draws the formatted text described by the specified object. + + + When drawing the same text repeatedly, using the DrawTextLayout method is more efficient than using the {{DrawText}} method because the text doesn't need to be formatted and the layout processed with each call. This method doesn't return an error code if it fails. To determine whether a drawing operation (such as DrawTextLayout) failed, check the result returned by the or methods. + + The point, described in device-independent pixels, at which the upper-left corner of the text described by textLayout is drawn. + The formatted text to draw. Any drawing effects that do not inherit from are ignored. If there are drawing effects that inherit from ID2D1Resource that are not brushes, this method fails and the render target is put in an error state. + The brush used to paint any text in textLayout that does not already have a brush associated with it as a drawing effect (specified by the method). + A value that indicates whether the text should be snapped to pixel boundaries and whether the text should be clipped to the layout rectangle. The default value is , which indicates that text should be snapped to pixel boundaries and it should not be clipped to the layout rectangle. + void ID2D1RenderTarget::DrawTextLayout([None] D2D1_POINT_2F origin,[In] IDWriteTextLayout* textLayout,[In] ID2D1Brush* defaultForegroundBrush,[None] D2D1_DRAW_TEXT_OPTIONS options) + + + + Draws the specified glyphs. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as DrawGlyphRun) failed, check the result returned by the or methods. + + The origin, in device-independent pixels, of the glyphs' baseline. + The glyphs to render. + The brush used to paint the specified glyphs. + A value that indicates how glyph metrics are used to measure text when it is formatted. The default value is DWRITE_MEASURING_MODE_NATURAL. + void ID2D1RenderTarget::DrawGlyphRun([None] D2D1_POINT_2F baselineOrigin,[In] const DWRITE_GLYPH_RUN* glyphRun,[In] ID2D1Brush* foregroundBrush,[None] DWRITE_MEASURING_MODE measuringMode) + + + + Applies the specified transform to the render target, replacing the existing transformation. All subsequent drawing operations occur in the transformed space. + + The transform to apply to the render target. + void ID2D1RenderTarget::SetTransform([In] const D2D1_MATRIX_3X2_F* transform) + + + + Gets the current transform of the render target. + + When this returns, contains the current transform of the render target. This parameter is passed uninitialized. + void ID2D1RenderTarget::GetTransform([Out] D2D1_MATRIX_3X2_F* transform) + + + + Sets the antialiasing mode of the render target. The antialiasing mode applies to all subsequent drawing operations, excluding text and glyph drawing operations. + + + To specify the antialiasing mode for text and glyph operations, use the {{SetTextAntialiasMode}} method. + + The antialiasing mode for future drawing operations. + void ID2D1RenderTarget::SetAntialiasMode([None] D2D1_ANTIALIAS_MODE antialiasMode) + + + + Retrieves the current antialiasing mode for nontext drawing operations. + + The current antialiasing mode for nontext drawing operations. + D2D1_ANTIALIAS_MODE ID2D1RenderTarget::GetAntialiasMode() + + + + Specifies the antialiasing mode to use for subsequent text and glyph drawing operations. + + The antialiasing mode to use for subsequent text and glyph drawing operations. + void ID2D1RenderTarget::SetTextAntialiasMode([None] D2D1_TEXT_ANTIALIAS_MODE textAntialiasMode) + + + + Gets the current antialiasing mode for text and glyph drawing operations. + + The current antialiasing mode for text and glyph drawing operations. + D2D1_TEXT_ANTIALIAS_MODE ID2D1RenderTarget::GetTextAntialiasMode() + + + + Specifies text rendering options to be applied to all subsequent text and glyph drawing operations. + + + If the settings specified by textRenderingParams are incompatible with the render target's text antialiasing mode (specified by {{SetTextAntialiasMode}}), subsequent text and glyph drawing operations will fail and put the render target into an error state. + + The text rendering options to be applied to all subsequent text and glyph drawing operations; NULL to clear current text rendering options. + void ID2D1RenderTarget::SetTextRenderingParams([In, Optional] IDWriteRenderingParams* textRenderingParams) + + + + Retrieves the render target's current text rendering options. + + + If the settings specified by textRenderingParams are incompatible with the render target's text antialiasing mode (specified by {{SetTextAntialiasMode}}), subsequent text and glyph drawing operations will fail and put the render target into an error state. + + When this method returns, textRenderingParamscontains the address of a reference to the render target's current text rendering options. + void ID2D1RenderTarget::GetTextRenderingParams([Out, Optional] IDWriteRenderingParams** textRenderingParams) + + + + Specifies a label for subsequent drawing operations. + + + The labels specified by this method are printed by debug error messages. If no tag is set, the default value for each tag is 0. + + A label to apply to subsequent drawing operations. + A label to apply to subsequent drawing operations. + void ID2D1RenderTarget::SetTags([None] D2D1_TAG tag1,[None] D2D1_TAG tag2) + + + + Gets the label for subsequent drawing operations. + + + If the same address is passed for both parameters, both parameters receive the value of the second tag. + + When this method returns, contains the first label for subsequent drawing operations. This parameter is passed uninitialized. If NULL is specified, no value is retrieved for this parameter. + When this method returns, contains the second label for subsequent drawing operations. This parameter is passed uninitialized. If NULL is specified, no value is retrieved for this parameter. + void ID2D1RenderTarget::GetTags([Out, Optional] D2D1_TAG* tag1,[Out, Optional] D2D1_TAG* tag2) + + + + Adds the specified layer to the render target so that it receives all subsequent drawing operations until {{PopLayer}} is called. + + + The PushLayer method allows a caller to begin redirecting rendering to a layer. All rendering operations are valid in a layer. The location of the layer is affected by the world transform set on the render target. Each {{PushLayer}} must have a matching {{PopLayer}} call. If there are more PopLayer calls than PushLayer calls, the render target is placed into an error state. If {{Flush}} is called before all outstanding layers are popped, the render target is placed into an error state, and an error is returned. The error state can be cleared by a call to {{EndDraw}}. A particular resource can be active only at one time. In other words, you cannot call a PushLayer method, and then immediately follow with another PushLayer method with the same layer resource. Instead, you must call the second PushLayer method with different layer resources. + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{PushLayer}}) failed, check the result returned by the or methods. + + The content bounds, geometric mask, opacity, opacity mask, and antialiasing options for the layer. + The layer that receives subsequent drawing operations. + void ID2D1RenderTarget::PushLayer([In] const D2D1_LAYER_PARAMETERS* layerParameters,[In] ID2D1Layer* layer) + + + + Stops redirecting drawing operations to the layer that is specified by the last {{PushLayer}} call. + + + A PopLayer must match a previous {{PushLayer}} call. This method doesn't return an error code if it fails. To determine whether a drawing operation (such as PopLayer) failed, check the result returned by the or methods. + + void ID2D1RenderTarget::PopLayer() + + + + Executes all pending drawing commands. + + + This command does not flush the device that is associated with the render target. Calling this method resets the error state of the render target. + + When this method returns, contains the tag for drawing operations that caused errors or 0 if there were no errors. This parameter is passed uninitialized. + When this method returns, contains the tag for drawing operations that caused errors or 0 if there were no errors. This parameter is passed uninitialized. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code and sets tag1 and tag2 to the tags that were active when the error occurred. If no error occurred, this method sets the error tag state to be (0,0). + HRESULT ID2D1RenderTarget::Flush([Out, Optional] D2D1_TAG* tag1,[Out, Optional] D2D1_TAG* tag2) + + + + Saves the current drawing state to the specified . + + When this method returns, contains the current drawing state of the render target. This parameter must be initialized before passing it to the method. + void ID2D1RenderTarget::SaveDrawingState([InOut] ID2D1DrawingStateBlock* drawingStateBlock) + + + + Sets the render target's drawing state to that of the specified . + + The new drawing state of the render target. + void ID2D1RenderTarget::RestoreDrawingState([In] ID2D1DrawingStateBlock* drawingStateBlock) + + + + Specifies a rectangle to which all subsequent drawing operations are clipped. + + + The clipRect is transformed by the current world transform set on the render target. After the transform is applied to the clipRect that is passed in, the axis-aligned bounding box for the clipRect is computed. For efficiency, the contents are clipped to this axis-aligned bounding box and not to the original clipRect that is passed in. The following diagrams show how a rotation transform is applied to the render target, the resulting clipRect, and a calculated axis-aligned bounding box. Assume the rectangle in the following illustration is a render target that is aligned to the screen pixels. Illustration of a rectangle (render target) Apply a rotation transform to the render target. In the following illustration, the black rectangle represents the original render target and the red dashed rectangle represents the transformed render target. Illustration of a rotated rectangle (transformed render target) After calling {{PushAxisAlignedClip}}, the rotation transform is applied to the clipRect. In the following illustration, the blue rectangle represents the transformed clipRect. Illustration of a small blue rectangle (transformed clipRect) inside a rotated rectangle The axis-aligned bounding box is calculated. The green dashed rectangle represents the bounding box in the following illustration. All contents are clipped to this axis-aligned bounding box. Illustration of a green bounding box around a small blue rectangle inside a rotated rectangle Note??If rendering operations fail or if {{PopAxisAlignedClip}} is not called, clip rects may cause some artifacts on the render target. PopAxisAlignedClip can be considered a drawing operation that is designed to fix the borders of a clipping region. Without this call, the borders of a clipped area may be not antialiased or otherwise corrected. The {{PushAxisAlignedClip}} and {{PopAxisAlignedClip}} must match. Otherwise, the error state is set. For the render target to continue receiving new commands, you can call {{Flush}} to clear the error. A {{PushAxisAlignedClip}} and {{PopAxisAlignedClip}} pair can occur around or within a PushLayer and PopLayer, but cannot overlap. For example, the sequence of PushAxisAlignedClip, {{PushLayer}}, {{PopLayer}}, PopAxisAlignedClip is valid, but the sequence of PushAxisAlignedClip, PushLayer, PopAxisAlignedClip, PopLayer is invalid. This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{PushAxisAlignedClip}}) failed, check the result returned by the or methods. + + The size and position of the clipping area, in device-independent pixels. + The antialiasing mode that is used to draw the edges of clip rects that have subpixel boundaries, and to blend the clip with the scene contents. The blending is performed once when the {{PopAxisAlignedClip}} method is called, and does not apply to each primitive within the layer. + void ID2D1RenderTarget::PushAxisAlignedClip([In] const D2D1_RECT_F* clipRect,[None] D2D1_ANTIALIAS_MODE antialiasMode) + + + + Removes the last axis-aligned clip from the render target. After this method is called, the clip is no longer applied to subsequent drawing operations. + + + A {{PushAxisAlignedClip}}/PopAxisAlignedClip pair can occur around or within a {{PushLayer}}/{{PopLayer}} pair, but may not overlap. For example, a PushAxisAlignedClip, PushLayer, PopLayer, PopAxisAlignedClip sequence is valid, but a PushAxisAlignedClip, PushLayer, PopAxisAlignedClip, PopLayer sequence is not. PopAxisAlignedClip must be called once for every call to {{PushAxisAlignedClip}}. For an example, see {{How to Clip with an Axis-Aligned Clip Rectangle}}. This method doesn't return an error code if it fails. To determine whether a drawing operation (such as PopAxisAlignedClip) failed, check the result returned by the or methods. + + void ID2D1RenderTarget::PopAxisAlignedClip() + + + + Clears the drawing area to the specified color. + + + Direct2D interprets the clearColor as straight alpha (not premultiplied). If the render target's alpha mode is , the alpha channel of clearColor is ignored and replaced with 1.0f (fully opaque). If the render target has an active clip (specified by {{PushAxisAlignedClip}}), the clear command is applied only to the area within the clip region. + + The color to which the drawing area is cleared. + void ID2D1RenderTarget::Clear([In, Optional] const D2D1_COLOR_F* clearColor) + + + + Initiates drawing on this render target. + + + Drawing operations can only be issued between a BeginDraw and {{EndDraw}} call. BeginDraw and EndDraw are used to indicate that a render target is in use by the Direct2D system. Different implementations of might behave differently when BeginDraw is called. An may be locked between BeginDraw/{{EndDraw}} calls, a DXGI surface render target might be acquired on BeginDraw and released on EndDraw, while an may begin batching at BeginDraw and may present on EndDraw, for example. The BeginDraw method must be called before rendering operations can be called, though state-setting and state-retrieval operations can be performed even outside of BeginDraw/{{EndDraw}}. After BeginDraw is called, a render target will normally build up a batch of rendering commands, but defer processing of these commands until either an internal buffer is full, the {{Flush}} method is called, or until {{EndDraw}} is called. The EndDraw method causes any batched drawing operations to complete, and then returns an HRESULT indicating the success of the operations and, optionally, the tag state of the render target at the time the error occurred. The EndDraw method always succeeds: it should not be called twice even if a previous EndDraw resulted in a failing HRESULT. If {{EndDraw}} is called without a matched call to BeginDraw, it returns an error indicating that BeginDraw must be called before EndDraw. Calling BeginDraw twice on a render target puts the target into an error state where nothing further is drawn, and returns an appropriate HRESULT and error information when EndDraw is called. + + + void ID2D1RenderTarget::BeginDraw() + + + + Ends drawing operations on the render target and indicates the current error state and associated tags. + + + Drawing operations can only be issued between a {{BeginDraw}} and EndDraw call. BeginDraw and EndDraw are use to indicate that a render target is in use by the Direct2D system. Different implementations of might behave differently when {{BeginDraw}} is called. An may be locked between BeginDraw/EndDraw calls, a DXGI surface render target might be acquired on BeginDraw and released on EndDraw, while an may begin batching at BeginDraw and may present on EndDraw, for example. The BeginDraw method must be called before rendering operations can be called, though state-setting and state-retrieval operations can be performed even outside of {{BeginDraw}}/EndDraw. After {{BeginDraw}} is called, a render target will normally build up a batch of rendering commands, but defer processing of these commands until either an internal buffer is full, the {{Flush}} method is called, or until EndDraw is called. The EndDraw method causes any batched drawing operations to complete, and then returns an HRESULT indicating the success of the operations and, optionally, the tag state of the render target at the time the error occurred. The EndDraw method always succeeds: it should not be called twice even if a previous EndDraw resulted in a failing HRESULT. If EndDraw is called without a matched call to {{BeginDraw}}, it returns an error indicating that BeginDraw must be called before EndDraw. Calling BeginDraw twice on a render target puts the target into an error state where nothing further is drawn, and returns an appropriate HRESULT and error information when EndDraw is called. + + + When this method returns, contains the tag for drawing operations that caused errors or 0 if there were no errors. This parameter is passed uninitialized. + When this method returns, contains the tag for drawing operations that caused errors or 0 if there were no errors. This parameter is passed uninitialized. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code and sets tag1 and tag2 to the tags that were active when the error occurred. + HRESULT ID2D1RenderTarget::EndDraw([Out, Optional] D2D1_TAG* tag1,[Out, Optional] D2D1_TAG* tag2) + + + + Retrieves the pixel format and alpha mode of the render target. + + The pixel format and alpha mode of the render target. + D2D1_PIXEL_FORMAT ID2D1RenderTarget::GetPixelFormat() + + + + Sets the dots per inch (DPI) of the render target. + + + This method specifies the mapping from pixel space to device-independent space for the render target. If both dpiX and dpiY are 0, the factory-read system DPI is chosen. If one parameter is zero and the other unspecified, the DPI is not changed. For , the DPI defaults to the most recently factory-read system DPI. The default value for all other render targets is 96 DPI. + + A value greater than or equal to zero that specifies the horizontal DPI of the render target. + A value greater than or equal to zero that specifies the vertical DPI of the render target. + void ID2D1RenderTarget::SetDpi([None] float dpiX,[None] float dpiY) + + + + Return the render target's dots per inch (DPI). + + + This method indicates the mapping from pixel space to device-independent space for the render target. For , the DPI defaults to the most recently factory-read system DPI. The default value for all other render targets is 96 DPI. + + When this method returns, contains the horizontal DPI of the render target. This parameter is passed uninitialized. + When this method returns, contains the vertical DPI of the render target. This parameter is passed uninitialized. + void ID2D1RenderTarget::GetDpi([Out] float* dpiX,[Out] float* dpiY) + + + + Returns the size of the render target in device-independent pixels. + + The current size of the render target in device-independent pixels. + D2D1_SIZE_F ID2D1RenderTarget::GetSize() + + + + Returns the size of the render target in device pixels. + + The size of the render target in device pixels. + D2D1_SIZE_U ID2D1RenderTarget::GetPixelSize() + + + + Gets the maximum size, in device-dependent units (pixels), of any one bitmap dimension supported by the render target. + + UINT32 The maximum size, in pixels, of any one bitmap dimension supported by the render target. + int ID2D1RenderTarget::GetMaximumBitmapSize() + + + + Indicates whether the render target supports the specified properties. + + + This method does not evaluate the DPI settings specified by the renderTargetProperties parameter. + + The render target properties to test. + BOOLTRUE if the specified render target properties are supported by this render target; otherwise, FALSE. + BOOL ID2D1RenderTarget::IsSupported([In] const D2D1_RENDER_TARGET_PROPERTIES* renderTargetProperties) + + + + Creates a render target that draws to a DirectX Graphics Infrastructure (DXGI) surface. + + + To write to a Direct3D surface, you obtain an and pass it to the {{CreateDxgiSurfaceRenderTarget}} method to create a DXGI surface render target; you can then use the DXGI surface render target to draw 2-D content to the DXGI surface. A DXGI surface render target is a type of . Like other Direct2D render targets, you can use it to create resources and issue drawing commands. The DXGI surface render target and the DXGI surface must use the same DXGI format. If you specify the {{DXGI_FORMAT_UNKOWN}} format when you create the render target, it will automatically use the surface's format.The DXGI surface render target does not perform DXGI surface synchronization. To work with Direct2D, the Direct3D device that provides the must be created with the D3D10_CREATE_DEVICE_BGRA_SUPPORT flag.For more information about creating and using DXGI surface render targets, see the {{Direct2D and Direct3D Interoperability Overview}}.When you create a render target and hardware acceleration is available, you allocate resources on the computer's GPU. By creating a render target once and retaining it as long as possible, you gain performance benefits. Your application should create render targets once and hold onto them for the life of the application or until the render target's {{EndDraw}} method returns the {{D2DERR_RECREATE_TARGET}} error. When you receive this error, you need to recreate the render target (and any resources it created). + + an instance of + The dxgi surface to bind this render target to + The rendering mode, pixel format, remoting options, DPI information, and the minimum DirectX support required for hardware rendering. For information about supported pixel formats, see {{Supported Pixel Formats and Alpha Modes}}. + + + + Draws the specified bitmap after scaling it to the size of the specified rectangle. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{DrawBitmap}}) failed, check the result returned by the or methods. + + The bitmap to render. + A value between 0.0f and 1.0f, inclusive, that specifies an opacity value to apply to the bitmap; this value is multiplied against the alpha values of the bitmap's contents. The default value is 1.0f. + The interpolation mode to use if the bitmap is scaled or rotated by the drawing operation. The default value is . + void ID2D1RenderTarget::DrawBitmap([In] ID2D1Bitmap* bitmap,[In, Optional] const D2D1_RECT_F* destinationRectangle,[None] float opacity,[None] D2D1_BITMAP_INTERPOLATION_MODE interpolationMode,[In, Optional] const D2D1_RECT_F* sourceRectangle) + + + + Draws the specified bitmap after scaling it to the size of the specified rectangle. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{DrawBitmap}}) failed, check the result returned by the or methods. + + The bitmap to render. + The size and position, in device-independent pixels in the render target's coordinate space, of the area to which the bitmap is drawn; NULL to draw the selected portion of the bitmap at the origin of the render target. If the rectangle is specified but not well-ordered, nothing is drawn, but the render target does not enter an error state. + A value between 0.0f and 1.0f, inclusive, that specifies an opacity value to apply to the bitmap; this value is multiplied against the alpha values of the bitmap's contents. The default value is 1.0f. + The interpolation mode to use if the bitmap is scaled or rotated by the drawing operation. The default value is . + void ID2D1RenderTarget::DrawBitmap([In] ID2D1Bitmap* bitmap,[In, Optional] const D2D1_RECT_F* destinationRectangle,[None] float opacity,[None] D2D1_BITMAP_INTERPOLATION_MODE interpolationMode,[In, Optional] const D2D1_RECT_F* sourceRectangle) + + + + Draws the specified bitmap after scaling it to the size of the specified rectangle. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{DrawBitmap}}) failed, check the result returned by the or methods. + + The bitmap to render. + A value between 0.0f and 1.0f, inclusive, that specifies an opacity value to apply to the bitmap; this value is multiplied against the alpha values of the bitmap's contents. The default value is 1.0f. + The interpolation mode to use if the bitmap is scaled or rotated by the drawing operation. The default value is . + The size and position, in device-independent pixels in the bitmap's coordinate space, of the area within the bitmap to be drawn; NULL to draw the entire bitmap. + void ID2D1RenderTarget::DrawBitmap([In] ID2D1Bitmap* bitmap,[In, Optional] const D2D1_RECT_F* destinationRectangle,[None] float opacity,[None] D2D1_BITMAP_INTERPOLATION_MODE interpolationMode,[In, Optional] const D2D1_RECT_F* sourceRectangle) + + + + Draws the outline of the specified ellipse using the specified stroke style. + + + The {{DrawEllipse}} method doesn't return an error code if it fails. To determine whether a drawing operation (such as DrawEllipse) failed, check the result returned by the or methods. + + The position and radius of the ellipse to draw, in device-independent pixels. + The brush used to paint the ellipse's outline. + void ID2D1RenderTarget::DrawEllipse([In] const D2D1_ELLIPSE* ellipse,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Draws the outline of the specified ellipse using the specified stroke style. + + + The {{DrawEllipse}} method doesn't return an error code if it fails. To determine whether a drawing operation (such as DrawEllipse) failed, check the result returned by the or methods. + + The position and radius of the ellipse to draw, in device-independent pixels. + The brush used to paint the ellipse's outline. + The thickness of the ellipse's stroke. The stroke is centered on the ellipse's outline. + void ID2D1RenderTarget::DrawEllipse([In] const D2D1_ELLIPSE* ellipse,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Draws the outline of the specified geometry. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as DrawGeometry) failed, check the result returned by the or methods. + + The geometry to draw. + The brush used to paint the geometry's stroke. + void ID2D1RenderTarget::DrawGeometry([In] ID2D1Geometry* geometry,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Draws the outline of the specified geometry. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as DrawGeometry) failed, check the result returned by the or methods. + + The geometry to draw. + The brush used to paint the geometry's stroke. + The thickness of the geometry's stroke. The stroke is centered on the geometry's outline. + void ID2D1RenderTarget::DrawGeometry([In] ID2D1Geometry* geometry,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Draws a line between the specified points. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as DrawLine) failed, check the result returned by the or methods. + + The start point of the line, in device-independent pixels. + The end point of the line, in device-independent pixels. + The brush used to paint the line's stroke. + void ID2D1RenderTarget::DrawLine([None] D2D1_POINT_2F point0,[None] D2D1_POINT_2F point1,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Draws a line between the specified points. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as DrawLine) failed, check the result returned by the or methods. + + The start point of the line, in device-independent pixels. + The end point of the line, in device-independent pixels. + The brush used to paint the line's stroke. + A value greater than or equal to 0.0f that specifies the width of the stroke. If this parameter isn't specified, it defaults to 1.0f. The stroke is centered on the line. + void ID2D1RenderTarget::DrawLine([None] D2D1_POINT_2F point0,[None] D2D1_POINT_2F point1,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Draws the outline of a rectangle that has the specified dimensions. + + + When this method fails, it does not return an error code. To determine whether a drawing method (such as {{DrawRectangle}}) failed, check the result returned by the or method. + + The dimensions of the rectangle to draw, in device-independent pixels. + The brush used to paint the rectangle's stroke. + void ID2D1RenderTarget::DrawRectangle([In] const D2D1_RECT_F* rect,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Draws the outline of a rectangle that has the specified dimensions and stroke style. + + + When this method fails, it does not return an error code. To determine whether a drawing method (such as {{DrawRectangle}}) failed, check the result returned by the or method. + + The dimensions of the rectangle to draw, in device-independent pixels. + The brush used to paint the rectangle's stroke. + A value greater than or equal to 0.0f that specifies the width of the rectangle's stroke. The stroke is centered on the rectangle's outline. + void ID2D1RenderTarget::DrawRectangle([In] const D2D1_RECT_F* rect,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Draws the outline of the specified rounded rectangle. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{DrawRoundedRectangle}}) failed, check the result returned by the or methods. + + The dimensions of the rounded rectangle to draw, in device-independent pixels. + The brush used to paint the rounded rectangle's outline. + void ID2D1RenderTarget::DrawRoundedRectangle([In] const D2D1_ROUNDED_RECT* roundedRect,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Draws the outline of the specified rounded rectangle. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{DrawRoundedRectangle}}) failed, check the result returned by the or methods. + + The dimensions of the rounded rectangle to draw, in device-independent pixels. + The brush used to paint the rounded rectangle's outline. + The width of the rounded rectangle's stroke. The stroke is centered on the rounded rectangle's outline. The default value is 1.0f. + void ID2D1RenderTarget::DrawRoundedRectangle([In] const D2D1_ROUNDED_RECT* roundedRect,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Draws the outline of the specified rounded rectangle using the specified stroke style. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{DrawRoundedRectangle}}) failed, check the result returned by the or methods. + + The dimensions of the rounded rectangle to draw, in device-independent pixels. + The brush used to paint the rounded rectangle's outline. + The width of the rounded rectangle's stroke. The stroke is centered on the rounded rectangle's outline. The default value is 1.0f. + The style of the rounded rectangle's stroke, or NULL to paint a solid stroke. The default value is NULL. + void ID2D1RenderTarget::DrawRoundedRectangle([In] const D2D1_ROUNDED_RECT* roundedRect,[In] ID2D1Brush* brush,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle) + + + + Draws the specified text using the format information provided by an object. + + + To create an object, create an and call its {{CreateTextFormat}} method. This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{DrawText}}) failed, check the result returned by the or methods. + + A reference to an array of Unicode characters to draw. + An object that describes formatting details of the text to draw, such as the font, the font size, and flow direction. + The size and position of the area in which the text is drawn. + The brush used to paint the text. + void ID2D1RenderTarget::DrawTextA([In, Buffer] const wchar_t* string,[None] int stringLength,[In] IDWriteTextFormat* textFormat,[In] const D2D1_RECT_F* layoutRect,[In] ID2D1Brush* defaultForegroundBrush,[None] D2D1_DRAW_TEXT_OPTIONS options,[None] DWRITE_MEASURING_MODE measuringMode) + + + + Draws the specified text using the format information provided by an object. + + + To create an object, create an and call its {{CreateTextFormat}} method. This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{DrawText}}) failed, check the result returned by the or methods. + + A reference to an array of Unicode characters to draw. + An object that describes formatting details of the text to draw, such as the font, the font size, and flow direction. + The size and position of the area in which the text is drawn. + The brush used to paint the text. + A value that indicates whether the text should be snapped to pixel boundaries and whether the text should be clipped to the layout rectangle. The default value is , which indicates that text should be snapped to pixel boundaries and it should not be clipped to the layout rectangle. + void ID2D1RenderTarget::DrawTextA([In, Buffer] const wchar_t* string,[None] int stringLength,[In] IDWriteTextFormat* textFormat,[In] const D2D1_RECT_F* layoutRect,[In] ID2D1Brush* defaultForegroundBrush,[None] D2D1_DRAW_TEXT_OPTIONS options,[None] DWRITE_MEASURING_MODE measuringMode) + + + + Draws the specified text using the format information provided by an object. + + + To create an object, create an and call its {{CreateTextFormat}} method. This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{DrawText}}) failed, check the result returned by the or methods. + + A reference to an array of Unicode characters to draw. + An object that describes formatting details of the text to draw, such as the font, the font size, and flow direction. + The size and position of the area in which the text is drawn. + The brush used to paint the text. + A value that indicates whether the text should be snapped to pixel boundaries and whether the text should be clipped to the layout rectangle. The default value is , which indicates that text should be snapped to pixel boundaries and it should not be clipped to the layout rectangle. + A value that indicates how glyph metrics are used to measure text when it is formatted. The default value is DWRITE_MEASURING_MODE_NATURAL. + void ID2D1RenderTarget::DrawTextA([In, Buffer] const wchar_t* string,[None] int stringLength,[In] IDWriteTextFormat* textFormat,[In] const D2D1_RECT_F* layoutRect,[In] ID2D1Brush* defaultForegroundBrush,[None] D2D1_DRAW_TEXT_OPTIONS options,[None] DWRITE_MEASURING_MODE measuringMode) + + + + Draws the formatted text described by the specified object. + + + When drawing the same text repeatedly, using the DrawTextLayout method is more efficient than using the {{DrawText}} method because the text doesn't need to be formatted and the layout processed with each call. This method doesn't return an error code if it fails. To determine whether a drawing operation (such as DrawTextLayout) failed, check the result returned by the or methods. + + The point, described in device-independent pixels, at which the upper-left corner of the text described by textLayout is drawn. + The formatted text to draw. Any drawing effects that do not inherit from are ignored. If there are drawing effects that inherit from ID2D1Resource that are not brushes, this method fails and the render target is put in an error state. + The brush used to paint any text in textLayout that does not already have a brush associated with it as a drawing effect (specified by the method). + void ID2D1RenderTarget::DrawTextLayout([None] D2D1_POINT_2F origin,[In] IDWriteTextLayout* textLayout,[In] ID2D1Brush* defaultForegroundBrush,[None] D2D1_DRAW_TEXT_OPTIONS options) + + + + Ends drawing operations on the render target and indicates the current error state and associated tags. + + + Drawing operations can only be issued between a {{BeginDraw}} and EndDraw call.BeginDraw and EndDraw are use to indicate that a render target is in use by the Direct2D system. Different implementations of might behave differently when {{BeginDraw}} is called. An may be locked between BeginDraw/EndDraw calls, a DXGI surface render target might be acquired on BeginDraw and released on EndDraw, while an may begin batching at BeginDraw and may present on EndDraw, for example. The BeginDraw method must be called before rendering operations can be called, though state-setting and state-retrieval operations can be performed even outside of {{BeginDraw}}/EndDraw. After {{BeginDraw}} is called, a render target will normally build up a batch of rendering commands, but defer processing of these commands until either an internal buffer is full, the {{Flush}} method is called, or until EndDraw is called. The EndDraw method causes any batched drawing operations to complete, and then returns an HRESULT indicating the success of the operations and, optionally, the tag state of the render target at the time the error occurred. The EndDraw method always succeeds: it should not be called twice even if a previous EndDraw resulted in a failing HRESULT. If EndDraw is called without a matched call to {{BeginDraw}}, it returns an error indicating that BeginDraw must be called before EndDraw. Calling BeginDraw twice on a render target puts the target into an error state where nothing further is drawn, and returns an appropriate HRESULT and error information when EndDraw is called. + + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code and sets tag1 and tag2 to the tags that were active when the error occurred. + + + + Paints the interior of the specified geometry. + + + If the opacityBrush parameter is not NULL, the alpha value of each pixel of the mapped opacityBrush is used to determine the resulting opacity of each corresponding pixel of the geometry. Only the alpha value of each color in the brush is used for this processing; all other color information is ignored. The alpha value specified by the brush is multiplied by the alpha value of the geometry after the geometry has been painted by brush. + When this method fails, it does not return an error code. To determine whether a drawing operation (such as FillGeometry) failed, check the result returned by the or method. + + The geometry to paint. + The brush used to paint the geometry's interior. + void FillGeometry([In] ID2D1Geometry* geometry,[In] ID2D1Brush* brush,[In, Optional] ID2D1Brush* opacityBrush) + + + + Applies the opacity mask described by the specified bitmap to a brush and uses that brush to paint a region of the render target. + + + For this method to work properly, the render target must be using the antialiasing mode. You can set the antialiasing mode by calling the method. This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{FillOpacityMask}}) failed, check the result returned by the or methods. + + The opacity mask to apply to the brush. The alpha value of each pixel in the region specified by sourceRectangle is multiplied with the alpha value of the brush after the brush has been mapped to the area defined by destinationRectangle. + The brush used to paint the region of the render target specified by destinationRectangle. + The type of content the opacity mask contains. The value is used to determine the color space in which the opacity mask is blended. + void ID2D1RenderTarget::FillOpacityMask([In] ID2D1Bitmap* opacityMask,[In] ID2D1Brush* brush,[None] D2D1_OPACITY_MASK_CONTENT content,[In, Optional] const D2D1_RECT_F* destinationRectangle,[In, Optional] const D2D1_RECT_F* sourceRectangle) + + + + Paints the interior of the specified rounded rectangle. + + + This method doesn't return an error code if it fails. To determine whether a drawing operation (such as {{FillRoundedRectangle}}) failed, check the result returned by the or methods. + + The dimensions of the rounded rectangle to paint, in device-independent pixels. + The brush used to paint the interior of the rounded rectangle. + void ID2D1RenderTarget::FillRoundedRectangle([In] const D2D1_ROUNDED_RECT* roundedRect,[In] ID2D1Brush* brush) + + + + Executes all pending drawing commands. + + + This command does not flush the device that is associated with the render target. Calling this method resets the error state of the render target. + + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code and sets tag1 and tag2 to the tags that were active when the error occurred. If no error occurred, this method sets the error tag state to be (0,0). + HRESULT ID2D1RenderTarget::Flush([Out, Optional] D2D1_TAG* tag1,[Out, Optional] D2D1_TAG* tag2) + + + + Gets the current transform of the render target. + + void ID2D1RenderTarget::GetTransform([Out] D2D1_MATRIX_3X2_F* transform) + + + + Retrieves the current antialiasing mode for nontext drawing operations. + + D2D1_ANTIALIAS_MODE ID2D1RenderTarget::GetAntialiasMode() + + + + Gets the current antialiasing mode for text and glyph drawing operations. + + D2D1_TEXT_ANTIALIAS_MODE ID2D1RenderTarget::GetTextAntialiasMode() + + + + Retrieves the render target's current text rendering options. + + + If the settings specified by textRenderingParams are incompatible with the render target's text antialiasing mode (specified by {{SetTextAntialiasMode}}), subsequent text and glyph drawing operations will fail and put the render target into an error state. + + void ID2D1RenderTarget::GetTextRenderingParams([Out, Optional] IDWriteRenderingParams** textRenderingParams) + + + + Retrieves the pixel format and alpha mode of the render target. + + D2D1_PIXEL_FORMAT ID2D1RenderTarget::GetPixelFormat() + + + + Returns the size of the render target in device-independent pixels. + + D2D1_SIZE_F ID2D1RenderTarget::GetSize() + + + + Returns the size of the render target in device pixels. + + D2D1_SIZE_U ID2D1RenderTarget::GetPixelSize() + + + + Gets the maximum size, in device-dependent units (pixels), of any one bitmap dimension supported by the render target. + + int ID2D1RenderTarget::GetMaximumBitmapSize() + + + + Get or set the default stroke width used for all methods that are not explicitly using it. Default is set to 1.0f. + + + + + Get or sets the dots per inch (DPI) of the render target. + + + This method specifies the mapping from pixel space to device-independent space for the render target. If both dpiX and dpiY are 0, the factory-read system DPI is chosen. If one parameter is zero and the other unspecified, the DPI is not changed. For , the DPI defaults to the most recently factory-read system DPI. The default value for all other render targets is 96 DPI. + + void ID2D1RenderTarget::SetDpi([None] float dpiX,[None] float dpiY) + + + + Creates a bitmap render target for use during intermediate offscreen drawing that is compatible with the current render targe with same size, pixel size and pixel format. + + an instance of + A value that specifies whether the new render target must be compatible with GDI. + HRESULT CreateCompatibleRenderTarget([In, Optional] const D2D1_SIZE_F* desiredSize,[In, Optional] const D2D1_SIZE_U* desiredPixelSize,[In, Optional] const D2D1_PIXEL_FORMAT* desiredFormat,[None] D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options,[Out] ID2D1BitmapRenderTarget** bitmapRenderTarget) + + + + Creates a bitmap render target for use during intermediate offscreen drawing that is compatible with the current render target with same pixel size and pixel format. + + an instance of + A value that specifies whether the new render target must be compatible with GDI. + The desired size of the new render target in device-independent pixels if it should be different from the original render target. For more information, see the Remarks section. + HRESULT CreateCompatibleRenderTarget([In, Optional] const D2D1_SIZE_F* desiredSize,[In, Optional] const D2D1_SIZE_U* desiredPixelSize,[In, Optional] const D2D1_PIXEL_FORMAT* desiredFormat,[None] D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options,[Out] ID2D1BitmapRenderTarget** bitmapRenderTarget) + + + + Creates a bitmap render target for use during intermediate offscreen drawing that is compatible with the current render target with same size and pixel size. + + an instance of + The desired pixel format and alpha mode of the new render target. If the pixel format is set to DXGI_FORMAT_UNKNOWN, the new render target uses the same pixel format as the original render target. If the alpha mode is , the alpha mode of the new render target defaults to D2D1_ALPHA_MODE_PREMULTIPLIED. For information about supported pixel formats, see {{Supported Pixel Formats and Alpha Modes}}. + A value that specifies whether the new render target must be compatible with GDI. + HRESULT CreateCompatibleRenderTarget([In, Optional] const D2D1_SIZE_F* desiredSize,[In, Optional] const D2D1_SIZE_U* desiredPixelSize,[In, Optional] const D2D1_PIXEL_FORMAT* desiredFormat,[None] D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options,[Out] ID2D1BitmapRenderTarget** bitmapRenderTarget) + + + + Creates a bitmap render target for use during intermediate offscreen drawing that is compatible with the current render target. + + + The pixel size and DPI of the new render target can be altered by specifying values for desiredSize or desiredPixelSize: If desiredSize is specified but desiredPixelSize is not, the pixel size is computed from the desired size using the parent target DPI. If the desiredSize maps to a integer-pixel size, the DPI of the compatible render target is the same as the DPI of the parent target. If desiredSize maps to a fractional-pixel size, the pixel size is rounded up to the nearest integer and the DPI for the compatible render target is slightly higher than the DPI of the parent render target. In all cases, the coordinate (desiredSize.width, desiredSize.height) maps to the lower-right corner of the compatible render target.If the desiredPixelSize is specified and desiredSize is not, the DPI of the new render target is the same as the original render target.If both desiredSize and desiredPixelSize are specified, the DPI of the new render target is computed to account for the difference in scale.If neither desiredSize nor desiredPixelSize is specified, the new render target size and DPI match the original render target. + + an instance of + The desired size of the new render target in device-independent pixels if it should be different from the original render target. For more information, see the Remarks section. + The desired size of the new render target in pixels if it should be different from the original render target. For more information, see the Remarks section. + The desired pixel format and alpha mode of the new render target. If the pixel format is set to DXGI_FORMAT_UNKNOWN, the new render target uses the same pixel format as the original render target. If the alpha mode is , the alpha mode of the new render target defaults to D2D1_ALPHA_MODE_PREMULTIPLIED. For information about supported pixel formats, see {{Supported Pixel Formats and Alpha Modes}}. + A value that specifies whether the new render target must be compatible with GDI. + HRESULT CreateCompatibleRenderTarget([In, Optional] const D2D1_SIZE_F* desiredSize,[In, Optional] const D2D1_SIZE_U* desiredPixelSize,[In, Optional] const D2D1_PIXEL_FORMAT* desiredFormat,[None] D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options,[Out] ID2D1BitmapRenderTarget** bitmapRenderTarget) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Retrieves the bitmap for this render target. The returned bitmap can be used for drawing operations. + + + The DPI for the obtained from GetBitmap will be the DPI of the when the render target was created. Changing the DPI of the ID2D1BitmapRenderTarget by calling {{SetDpi}} doesn't affect the DPI of the bitmap, even if SetDpi is called before GetBitmap. Using SetDpi to change the DPI of the ID2D1BitmapRenderTarget does affect how contents are rendered into the bitmap: it just doesn't affect the DPI of the bitmap retrieved by GetBitmap. + + When this method returns, contains the address of a reference to the bitmap for this render target. This bitmap can be used for drawing operations. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1BitmapRenderTarget::GetBitmap([Out] ID2D1Bitmap** bitmap) + + + + Retrieves the bitmap for this render target. The returned bitmap can be used for drawing operations. + + + The DPI for the obtained from GetBitmap will be the DPI of the when the render target was created. Changing the DPI of the ID2D1BitmapRenderTarget by calling {{SetDpi}} doesn't affect the DPI of the bitmap, even if SetDpi is called before GetBitmap. Using SetDpi to change the DPI of the ID2D1BitmapRenderTarget does affect how contents are rendered into the bitmap: it just doesn't affect the DPI of the bitmap retrieved by GetBitmap. + + HRESULT ID2D1BitmapRenderTarget::GetBitmap([Out] ID2D1Bitmap** bitmap) + + + + Default abstract implementation of TextRenderer. Need to implement a least a DrawXXX method to use it. + + + + + Determines whether pixel snapping is disabled. The recommended default is FALSE, + unless doing animation that requires subpixel vertical placement. + + The context passed to IDWriteTextLayout::Draw. + Receives TRUE if pixel snapping is disabled or FALSE if it not. + HRESULT IsPixelSnappingDisabled([None] void* clientDrawingContext,[Out] BOOL* isDisabled) + + + + Gets a transform that maps abstract coordinates to DIPs. + + The drawing context passed to . + a structure which has transform information for pixel snapping. + HRESULT GetCurrentTransform([None] void* clientDrawingContext,[Out] DWRITE_MATRIX* transform) + + + + Gets the number of physical pixels per DIP. + + + Because a DIP (device-independent pixel) is 1/96 inch, the pixelsPerDip value is the number of logical pixels per inch divided by 96. + + The drawing context passed to . + the number of physical pixels per DIP + HRESULT GetPixelsPerDip([None] void* clientDrawingContext,[Out] FLOAT* pixelsPerDip) + + + + IDWriteTextLayout::Draw calls this function to instruct the client to render a run of glyphs. + + + The function calls this callback function with all the information about glyphs to render. The application implements this callback by mostly delegating the call to the underlying platform's graphics API such as {{Direct2D}} to draw glyphs on the drawing context. An application that uses GDI can implement this callback in terms of the method. + + The application-defined drawing context passed to . + The pixel location (X-coordinate) at the baseline origin of the glyph run. + The pixel location (Y-coordinate) at the baseline origin of the glyph run. + The measuring method for glyphs in the run, used with the other properties to determine the rendering mode. + Pointer to the glyph run instance to render. + A pointer to the optional glyph run description instance which contains properties of the characters associated with this run. + Application-defined drawing effects for the glyphs to render. Usually this argument represents effects such as the foreground brush filling the interior of text. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT DrawGlyphRun([None] void* clientDrawingContext,[None] FLOAT baselineOriginX,[None] FLOAT baselineOriginY,[None] DWRITE_MEASURING_MODE measuringMode,[In] const DWRITE_GLYPH_RUN* glyphRun,[In] const DWRITE_GLYPH_RUN_DESCRIPTION* glyphRunDescription,[None] IUnknown* clientDrawingEffect) + + + + IDWriteTextLayout::Draw calls this function to instruct the client to draw an underline. + + + A single underline can be broken into multiple calls, depending on how the formatting changes attributes. If font sizes/styles change within an underline, the thickness and offset will be averaged weighted according to characters. To get an appropriate starting pixel position, add underline::offset to the baseline. Otherwise there will be no spacing between the text. The x coordinate will always be passed as the left side, regardless of text directionality. This simplifies drawing and reduces the problem of round-off that could potentially cause gaps or a double stamped alpha blend. To avoid alpha overlap, round the end points to the nearest device pixel. + + The application-defined drawing context passed to IDWriteTextLayout::Draw. + The pixel location (X-coordinate) at the baseline origin of the run where underline applies. + The pixel location (Y-coordinate) at the baseline origin of the run where underline applies. + Pointer to a structure containing underline logical information. + Application-defined effect to apply to the underline. Usually this argument represents effects such as the foreground brush filling the interior of a line. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT DrawUnderline([None] void* clientDrawingContext,[None] FLOAT baselineOriginX,[None] FLOAT baselineOriginY,[In] const DWRITE_UNDERLINE* underline,[None] IUnknown* clientDrawingEffect) + + + + IDWriteTextLayout::Draw calls this function to instruct the client to draw a strikethrough. + + + A single strikethrough can be broken into multiple calls, depending on how the formatting changes attributes. Strikethrough is not averaged across font sizes/styles changes. To get an appropriate starting pixel position, add strikethrough::offset to the baseline. Like underlines, the x coordinate will always be passed as the left side, regardless of text directionality. + + The application-defined drawing context passed to IDWriteTextLayout::Draw. + The pixel location (X-coordinate) at the baseline origin of the run where strikethrough applies. + The pixel location (Y-coordinate) at the baseline origin of the run where strikethrough applies. + Pointer to a structure containing strikethrough logical information. + Application-defined effect to apply to the strikethrough. Usually this argument represents effects such as the foreground brush filling the interior of a line. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT DrawStrikethrough([None] void* clientDrawingContext,[None] FLOAT baselineOriginX,[None] FLOAT baselineOriginY,[In] const DWRITE_STRIKETHROUGH* strikethrough,[None] IUnknown* clientDrawingEffect) + + + + IDWriteTextLayout::Draw calls this application callback when it needs to draw an inline object. + + The application-defined drawing context passed to IDWriteTextLayout::Draw. + X-coordinate at the top-left corner of the inline object. + Y-coordinate at the top-left corner of the inline object. + The application-defined inline object set using IDWriteTextFormat::SetInlineObject. + A Boolean flag that indicates whether the object's baseline runs alongside the baseline axis of the line. + A Boolean flag that indicates whether the object is in a right-to-left context, hinting that the drawing may want to mirror the normal image. + Application-defined drawing effects for the glyphs to render. Usually this argument represents effects such as the foreground brush filling the interior of a line. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT DrawInlineObject([None] void* clientDrawingContext,[None] FLOAT originX,[None] FLOAT originY,[None] IDWriteInlineObject* inlineObject,[None] BOOL isSideways,[None] BOOL isRightToLeft,[None] IUnknown* clientDrawingEffect) + + + + Internal TextRenderer Callback + + + + + Initializes a new instance of the class. + + The callback. + + + + Gets or sets the callback. + + The callback. + + + HRESULT DrawGlyphRun([None] void* clientDrawingContext,[None] FLOAT baselineOriginX,[None] FLOAT baselineOriginY,[None] DWRITE_MEASURING_MODE measuringMode,[In] const DWRITE_GLYPH_RUN* glyphRun,[In] const DWRITE_GLYPH_RUN_DESCRIPTION* glyphRunDescription,[None] IUnknown* clientDrawingEffect) + + + HRESULT DrawUnderline([None] void* clientDrawingContext,[None] FLOAT baselineOriginX,[None] FLOAT baselineOriginY,[In] const DWRITE_UNDERLINE* underline,[None] IUnknown* clientDrawingEffect) + + + HRESULT DrawStrikethrough([None] void* clientDrawingContext,[None] FLOAT baselineOriginX,[None] FLOAT baselineOriginY,[In] const DWRITE_STRIKETHROUGH* strikethrough,[None] IUnknown* clientDrawingEffect) + + + HRESULT DrawInlineObject([None] void* clientDrawingContext,[None] FLOAT originX,[None] FLOAT originY,[None] IDWriteInlineObject* inlineObject,[None] BOOL isSideways,[None] BOOL isRightToLeft,[None] IUnknown* clientDrawingEffect) + + + + Represents a font typography setting. + + IDWriteTypography + + + + Creates a typography object for use in a text layout. + + an instance of + HRESULT IDWriteFactory::CreateTypography([Out] IDWriteTypography** typography) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Adds an OpenType font feature. + + A structure that contains the OpenType name identifier and the execution parameter for the font feature being added. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteTypography::AddFontFeature([None] DWRITE_FONT_FEATURE fontFeature) + + + + Gets the number of OpenType font features for the current font. + + + A single run of text can be associated with more than one typographic feature. The object holds a list of these font features. + + The number of font features for the current text format. + int IDWriteTypography::GetFontFeatureCount() + + + + Gets the font feature at the specified index. + + + A single run of text can be associated with more than one typographic feature. The object holds a list of these font features. + + The zero-based index of the font feature to retrieve. + When this method returns, contains the font feature which is at the specified index. + HRESULT IDWriteTypography::GetFontFeature([None] int fontFeatureIndex,[Out] DWRITE_FONT_FEATURE* fontFeature) + + + + Gets the number of OpenType font features for the current font. + + + A single run of text can be associated with more than one typographic feature. The object holds a list of these font features. + + int IDWriteTypography::GetFontFeatureCount() + + + + Contains the center point, x-radius, and y-radius of an ellipse. + + D2D1_ELLIPSE + + + + Initializes a new instance of the struct. + + The center. + The radius X. + The radius Y. + + + + The center point of the ellipse. + + D2D1_POINT_2F point + + + + The X-radius of the ellipse. + + float radiusX + + + + The Y-radius of the ellipse. + + float radiusY + + + + Provides access to an device context that can accept GDI drawing commands. + + ID2D1GdiInteropRenderTarget + + + + Indicates that drawing with the device context retrieved using the {{GetDC}} method is finished. + + + ReleaseDC must be called once for each call to {{GetDC}}. + + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1GdiInteropRenderTarget::ReleaseDC([In, Optional] const RECT* update) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Retrieves the device context associated with this render target. + + + Calling this method flushes the render target. This command can be called only after {{BeginDraw}} and before {{EndDraw}}. It should not be called between {{PushAxisAlignedClip}}/{{PopAxisAlignedClip}} commands or between {{PushLayer}}/{{PopLayer}}. {{ReleaseDC}} must be called once for each call to GetDC. + + A value that specifies whether the device context should be cleared. + When this method returns, contains the device context associated with this render target. You must allocate storage for this parameter. + HRESULT ID2D1GdiInteropRenderTarget::GetDC([None] D2D1_DC_INITIALIZE_MODE mode,[Out] void** hdc) + + + + Indicates that drawing with the device context retrieved using the {{GetDC}} method is finished. + + + ReleaseDC must be called once for each call to {{GetDC}}. + + The modified region of the device context, or NULL to specify the entire render target. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1GdiInteropRenderTarget::ReleaseDC([In, Optional] const RECT* update) + + + + Indicates the measuring method used for text layout. + + DWRITE_MEASURING_MODE + + + + Specifies that text is measured using glyph ideal metrics whose values are independent to the current display resolution. + + DWRITE_MEASURING_MODE_NATURAL + + + + Specifies that text is measured using glyph display-compatible metrics whose values tuned for the current display resolution. + + DWRITE_MEASURING_MODE_GDI_CLASSIC + + + + Specifies that text is measured using the same glyph display metrics as text measured by GDI using a font created with CLEARTYPE_NATURAL_QUALITY. + + DWRITE_MEASURING_MODE_GDI_NATURAL + + + + The type of a font represented by a single font file. Font formats that consist of multiple files, for example Type 1 .PFM and .PFB, have separate enum values for each of the file types. + + DWRITE_FONT_FILE_TYPE + + + + Font type is not recognized by the DirectWrite font system. + + DWRITE_FONT_FILE_TYPE_UNKNOWN + + + + OpenType font with CFF outlines. + + DWRITE_FONT_FILE_TYPE_CFF + + + + OpenType font with TrueType outlines. + + DWRITE_FONT_FILE_TYPE_TRUETYPE + + + + OpenType font that contains a TrueType collection. + + DWRITE_FONT_FILE_TYPE_TRUETYPE_COLLECTION + + + + Type 1 PFM font. + + DWRITE_FONT_FILE_TYPE_TYPE1_PFM + + + + Type 1 PFB font. + + DWRITE_FONT_FILE_TYPE_TYPE1_PFB + + + + Vector .FON font. + + DWRITE_FONT_FILE_TYPE_VECTOR + + + + Bitmap .FON font. + + DWRITE_FONT_FILE_TYPE_BITMAP + + + + Indicates the file format of a complete font face. + + + Font formats that consist of multiple files, such as Type 1 .PFM and .PFB, have a single enum entry. + + DWRITE_FONT_FACE_TYPE + + + + OpenType font face with CFF outlines. + + DWRITE_FONT_FACE_TYPE_CFF + + + + OpenType font face with TrueType outlines. + + DWRITE_FONT_FACE_TYPE_TRUETYPE + + + + OpenType font face that is a part of a TrueType collection. + + DWRITE_FONT_FACE_TYPE_TRUETYPE_COLLECTION + + + + A Type 1 font face. + + DWRITE_FONT_FACE_TYPE_TYPE1 + + + + A vector .FON format font face. + + DWRITE_FONT_FACE_TYPE_VECTOR + + + + A bitmap .FON format font face. + + DWRITE_FONT_FACE_TYPE_BITMAP + + + + Font face type is not recognized by the DirectWrite font system. + + DWRITE_FONT_FACE_TYPE_UNKNOWN + + + + Specifies algorithmic style simulations to be applied to the font face. Bold and oblique simulations can be combined via bitwise OR operation. + + + Style simulations are not recommended for good typographic quality. + + DWRITE_FONT_SIMULATIONS + + + + Indicates that no simulations are applied to the font face. + + DWRITE_FONT_SIMULATIONS_NONE + + + + Indicates that algorithmic emboldening is applied to the font face. DWRITE_FONT_SIMULATIONS_BOLD increases weight by applying a widening algorithm to the glyph outline. This may be used to simulate a bold weight where no designed bold weight is available. + + DWRITE_FONT_SIMULATIONS_BOLD + + + + Indicates that algorithmic italicization is applied to the font face. DWRITE_FONT_SIMULATIONS_OBLIQUE applies obliquing (shear) to the glyph outline. This may be used to simulate an oblique/italic style where no designed oblique/italic style is available. + + DWRITE_FONT_SIMULATIONS_OBLIQUE + + + + Represents the density of a typeface, in terms of the lightness or heaviness of the strokes. The enumerated values correspond to the usWeightClass definition in the OpenType specification. The usWeightClass represents an integer value between 1 and 999. Lower values indicate lighter weights; higher values indicate heavier weights. + + + Weight differences are generally differentiated by an increased stroke or thickness that is associated with a given character in a typeface, as compared to a "normal" character from that same typeface. + The following illustration shows an example of Normal and UltraBold weights for the Palatino Linotype typeface. ? Illustration of the letter "W" in Normal and UltraBold weights ? Note??Not all weights are available for all typefaces. When a weight is not available for a typeface, the closest matching weight is returned. Font weight values less than 1 or greater than 999 are considered invalid, and they are rejected by font API functions. + + DWRITE_FONT_WEIGHT + + + + Predefined font weight : Thin (100). + + DWRITE_FONT_WEIGHT_THIN + + + + Predefined font weight : Extra-light (200). + + DWRITE_FONT_WEIGHT_EXTRA_LIGHT + + + + Predefined font weight : Ultra-light (200). + + DWRITE_FONT_WEIGHT_ULTRA_LIGHT + + + + Predefined font weight : Light (300). + + DWRITE_FONT_WEIGHT_LIGHT + + + + Predefined font weight : Normal (400). + + DWRITE_FONT_WEIGHT_NORMAL + + + + Predefined font weight : Regular (400). + + DWRITE_FONT_WEIGHT_REGULAR + + + + Predefined font weight : Medium (500). + + DWRITE_FONT_WEIGHT_MEDIUM + + + + Predefined font weight : Demi-bold (600). + + DWRITE_FONT_WEIGHT_DEMI_BOLD + + + + Predefined font weight : Semi-bold (600). + + DWRITE_FONT_WEIGHT_SEMI_BOLD + + + + Predefined font weight : Bold (700). + + DWRITE_FONT_WEIGHT_BOLD + + + + Predefined font weight : Extra-bold (800). + + DWRITE_FONT_WEIGHT_EXTRA_BOLD + + + + Predefined font weight : Ultra-bold (800). + + DWRITE_FONT_WEIGHT_ULTRA_BOLD + + + + Predefined font weight : Black (900). + + DWRITE_FONT_WEIGHT_BLACK + + + + Predefined font weight : Heavy (900). + + DWRITE_FONT_WEIGHT_HEAVY + + + + Predefined font weight : Extra-black (950). + + DWRITE_FONT_WEIGHT_EXTRA_BLACK + + + + Predefined font weight : Ultra-black (950). + + DWRITE_FONT_WEIGHT_ULTRA_BLACK + + + + Represents the degree to which a font has been stretched compared to a font's normal aspect ratio. The enumerated values correspond to the usWidthClass definition in the OpenType specification. The usWidthClass represents an integer value between 1 and 9?lower values indicate narrower widths; higher values indicate wider widths. + + + A font stretch describes the degree to which a font form is stretched from its normal aspect ratio, which is the original width to height ratio specified for the glyphs in the font. + The following illustration shows an example of Normal and Condensed stretches for the Rockwell Bold typeface. ? Illustration of ?D2D? text in Normal and Condensed font stretch ? Note??Values other than the ones defined in the enumeration are considered to be invalid, and are rejected by font API functions. + + DWRITE_FONT_STRETCH + + + + Predefined font stretch : Not known (0). + + DWRITE_FONT_STRETCH_UNDEFINED + + + + Predefined font stretch : Ultra-condensed (1). + + DWRITE_FONT_STRETCH_ULTRA_CONDENSED + + + + Predefined font stretch : Extra-condensed (2). + + DWRITE_FONT_STRETCH_EXTRA_CONDENSED + + + + Predefined font stretch : Condensed (3). + + DWRITE_FONT_STRETCH_CONDENSED + + + + Predefined font stretch : Semi-condensed (4). + + DWRITE_FONT_STRETCH_SEMI_CONDENSED + + + + Predefined font stretch : Normal (5). + + DWRITE_FONT_STRETCH_NORMAL + + + + Predefined font stretch : Medium (5). + + DWRITE_FONT_STRETCH_MEDIUM + + + + Predefined font stretch : Semi-expanded (6). + + DWRITE_FONT_STRETCH_SEMI_EXPANDED + + + + Predefined font stretch : Expanded (7). + + DWRITE_FONT_STRETCH_EXPANDED + + + + Predefined font stretch : Extra-expanded (8). + + DWRITE_FONT_STRETCH_EXTRA_EXPANDED + + + + Predefined font stretch : Ultra-expanded (9). + + DWRITE_FONT_STRETCH_ULTRA_EXPANDED + + + + Represents the style of a font face as normal, italic, or oblique. + + + Three terms categorize the slant of a font: normal, italic, and oblique. Font styleDescription NormalThe characters in a normal, or roman, font are upright. + Italic + The characters in an italic font are truly slanted and appear as they were designed. + ObliqueThe characters in an oblique font are artificially slanted. ? For Oblique, the slant is achieved by performing a shear transformation on the characters from a normal font. When a true italic font is not available on a computer or printer, an oblique style can be generated from the normal font and used to simulate an italic font. The following illustration shows the normal, italic, and oblique font styles for the Palatino Linotype font. Notice how the italic font style has a more flowing and visually appealing appearance than the oblique font style, which is simply created by skewing the normal font style version of the text. ? Illustration of normal, italic, and oblique font styles ? Note?? Values other than the ones defined in the enumeration are considered to be invalid, and they are rejected by font API functions. + + DWRITE_FONT_STYLE + + + + Font style : Normal. + + DWRITE_FONT_STYLE_NORMAL + + + + Font style : Oblique. + + DWRITE_FONT_STYLE_OBLIQUE + + + + Font style : Italic. + + DWRITE_FONT_STYLE_ITALIC + + + + The informational string enumeration which identifies a string embedded in a font file. + + DWRITE_INFORMATIONAL_STRING_ID + + + + Indicates the string containing the unspecified name ID. + + DWRITE_INFORMATIONAL_STRING_NONE + + + + Indicates the string containing the copyright notice provided by the font. + + DWRITE_INFORMATIONAL_STRING_COPYRIGHT_NOTICE + + + + Indicates the string containing a version number. + + DWRITE_INFORMATIONAL_STRING_VERSION_STRINGS + + + + Indicates the string containing the trademark information provided by the font. + + DWRITE_INFORMATIONAL_STRING_TRADEMARK + + + + Indicates the string containing the name of the font manufacturer. + + DWRITE_INFORMATIONAL_STRING_MANUFACTURER + + + + Indicates the string containing the name of the font designer. + + DWRITE_INFORMATIONAL_STRING_DESIGNER + + + + Indicates the string containing the URL of the font designer (with protocol, e.g., http://, ftp://). + + DWRITE_INFORMATIONAL_STRING_DESIGNER_URL + + + + Indicates the string containing the description of the font. This may also contain revision information, usage recommendations, history, features, etc. + + DWRITE_INFORMATIONAL_STRING_DESCRIPTION + + + + Indicates the string containing the URL of the font vendor (with protocol, e.g., http://, ftp://). If a unique serial number is embedded in the URL, it can be used to register the font. + + DWRITE_INFORMATIONAL_STRING_FONT_VENDOR_URL + + + + Indicates the string containing the description of how the font may be legally used, or different example scenarios for licensed use. + + DWRITE_INFORMATIONAL_STRING_LICENSE_DESCRIPTION + + + + Indicates the string containing the URL where additional licensing information can be found. + + DWRITE_INFORMATIONAL_STRING_LICENSE_INFO_URL + + + + Indicates the string containing the GDI-compatible family name. Since GDI allows a maximum of four fonts per family, fonts in the same family may have different GDI-compatible family names (e.g., "Arial", "Arial Narrow", "Arial Black"). + + DWRITE_INFORMATIONAL_STRING_WIN32_FAMILY_NAMES + + + + Indicates the string containing a GDI-compatible subfamily name. + + DWRITE_INFORMATIONAL_STRING_WIN32_SUBFAMILY_NAMES + + + + Indicates the string containing the family name preferred by the designer. This enables font designers to group more than four fonts in a single family without losing compatibility with GDI. This name is typically only present if it differs from the GDI-compatible family name. + + DWRITE_INFORMATIONAL_STRING_PREFERRED_FAMILY_NAMES + + + + Indicates the string containing the subfamily name preferred by the designer. This name is typically only present if it differs from the GDI-compatible subfamily name. + + DWRITE_INFORMATIONAL_STRING_PREFERRED_SUBFAMILY_NAMES + + + + Contains sample text for display in font lists. This can be the font name or any other text that the designer thinks is the best example to display the font in. + + DWRITE_INFORMATIONAL_STRING_SAMPLE_TEXT + + + + Specifies the type of DirectWrite factory object. + + + A DirectWrite factory object contains information about its internal state, such as font loader registration and cached font data. In most cases you should use the shared factory object, because it allows multiple components that use DirectWrite to share internal DirectWrite state information, thereby reducing memory usage. However, there are cases when it is desirable to reduce the impact of a component on the rest of the process, such as a plug-in from an untrusted source, by sandboxing and isolating it from the rest of the process components. In such cases, you should use an isolated factory for the sandboxed component. + + DWRITE_FACTORY_TYPE + + + + Indicates that the DirectWrite factory is a shared factory and that it allows for the reuse of cached font data across multiple in-process components. Such factories also take advantage of cross process font caching components for better performance. + + DWRITE_FACTORY_TYPE_SHARED + + + + Indicates that the DirectWrite factory object is isolated. Objects created from the isolated factory do not interact with internal DirectWrite state from other components. + + DWRITE_FACTORY_TYPE_ISOLATED + + + + Represents the internal structure of a device pixel (that is the physical arrangement of red, green, and blue color components) that is assumed for purposes of rendering text. + + DWRITE_PIXEL_GEOMETRY + + + + The red, green, and blue color components of each pixel are assumed to occupy the same point. + + DWRITE_PIXEL_GEOMETRY_FLAT + + + + Each pixel is composed of three vertical stripes, with red on the left, green in the center, and blue on the right. This is the most common pixel geometry for LCD monitors. + + DWRITE_PIXEL_GEOMETRY_RGB + + + + Each pixel is composed of three vertical stripes, with blue on the left, green in the center, and red on the right. + + DWRITE_PIXEL_GEOMETRY_BGR + + + + Represents a method of rendering glyphs. + + DWRITE_RENDERING_MODE + + + + Specifies that the rendering mode is determined automatically, based on the font and size. + + DWRITE_RENDERING_MODE_DEFAULT + + + + Specifies that no anti-aliasing is performed. Each pixel is either set to the foreground color of the text or retains the color of the background. + + DWRITE_RENDERING_MODE_ALIASED + + + + Specifies ClearType rendering with the same metrics as bi-level text. Glyphs can only be positioned on whole-pixel boundaries. + + DWRITE_RENDERING_MODE_CLEARTYPE_GDI_CLASSIC + + + + Specifies ClearType rendering with the same metrics as text rendering using GDI using a font created with CLEARTYPE_NATURAL_QUALITY. Glyph metrics are closer to their ideal values than with bi-level text, but glyphs are still positioned on whole-pixel boundaries. + + DWRITE_RENDERING_MODE_CLEARTYPE_GDI_NATURAL + + + + Specifies ClearType rendering with anti-aliasing in the horizontal dimension only. This is typically used with small to medium font sizes (up to 16 ppem). + + DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL + + + + Specifies ClearType rendering with anti-aliasing in both horizontal and vertical dimensions. This is typically used at larger sizes to makes curves and diagonal lines look smoother, at the expense of some softness. + + DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL_SYMMETRIC + + + + Specifies that rendering should bypass the rasterizer and use the outlines directly. This is typically used at very large sizes. + + DWRITE_RENDERING_MODE_OUTLINE + + + + Specifies the direction in which reading progresses. + + DWRITE_READING_DIRECTION + + + + Indicates that reading progresses from left to right. + + DWRITE_READING_DIRECTION_LEFT_TO_RIGHT + + + + Indicates that reading progresses from right to left. + + DWRITE_READING_DIRECTION_RIGHT_TO_LEFT + + + + Indicates the direction of flow for placing lines of text in a paragraph. + + DWRITE_FLOW_DIRECTION + + + + Specifies that text lines are placed from top to bottom. + + DWRITE_FLOW_DIRECTION_TOP_TO_BOTTOM + + + + Specifies the alignment of paragraph text along the reading direction axis, relative to the leading and trailing edge of the layout box. + + DWRITE_TEXT_ALIGNMENT + + + + The leading edge of the paragraph text is aligned to the leading edge of the layout box. + + DWRITE_TEXT_ALIGNMENT_LEADING + + + + The trailing edge of the paragraph text is aligned to the trailing edge of the layout box. + + DWRITE_TEXT_ALIGNMENT_TRAILING + + + + The center of the paragraph text is aligned to the center of the layout box. + + DWRITE_TEXT_ALIGNMENT_CENTER + + + + Specifies the alignment of paragraph text along the flow direction axis, relative to the top and bottom of the flow's layout box. + + DWRITE_PARAGRAPH_ALIGNMENT + + + + The top of the text flow is aligned to the top edge of the layout box. + + DWRITE_PARAGRAPH_ALIGNMENT_NEAR + + + + The bottom of the text flow is aligned to the bottom edge of the layout box. + + DWRITE_PARAGRAPH_ALIGNMENT_FAR + + + + The center of the flow is aligned to the center of the layout box. + + DWRITE_PARAGRAPH_ALIGNMENT_CENTER + + + + Specifies the word wrapping to be used in a particular multiline paragraph. + + DWRITE_WORD_WRAPPING + + + + Indicates that words are broken across lines to avoid text overflowing the layout box. + + DWRITE_WORD_WRAPPING_WRAP + + + + Indicates that words are kept within the same line even when it overflows the layout box. This option is often used with scrolling to reveal overflow text. + + DWRITE_WORD_WRAPPING_NO_WRAP + + + + The method used for line spacing in a text layout. + + + The line spacing method is set by using the {{SetLineSpacing}} method of the or interfaces. To get the current line spacing method of a text format or text layou use the {{GetLineSpacing}}. + + DWRITE_LINE_SPACING_METHOD + + + + Line spacing depends solely on the content, adjusting to accommodate the size of fonts and inline objects. + + DWRITE_LINE_SPACING_METHOD_DEFAULT + + + + Lines are explicitly set to uniform spacing, regardless of the size of fonts and inline objects. This can be useful to avoid the uneven appearance that can occur from font fallback. + + DWRITE_LINE_SPACING_METHOD_UNIFORM + + + + Specifies the text granularity used to trim text overflowing the layout box. + + DWRITE_TRIMMING_GRANULARITY + + + + No trimming occurs. Text flows beyond the layout width. + + DWRITE_TRIMMING_GRANULARITY_NONE + + + + Trimming occurs at a character cluster boundary. + + DWRITE_TRIMMING_GRANULARITY_CHARACTER + + + + Trimming occurs at a word boundary. + + DWRITE_TRIMMING_GRANULARITY_WORD + + + + A value that indicates the typographic feature of text supplied by the font. + + DWRITE_FONT_FEATURE_TAG + + + + Replaces figures separated by a slash with an alternative form. Equivalent OpenType tag: 'afrc' + + DWRITE_FONT_FEATURE_TAG_ALTERNATIVE_FRACTIONS + + + + Turns capital characters into petite capitals. It is generally used for words which would otherwise be set in all caps, such as acronyms, but which are desired in petite-cap form to avoid disrupting the flow of text. See the pcap feature description for notes on the relationship of caps, smallcaps and petite caps. Equivalent OpenType tag: 'c2pc' + + DWRITE_FONT_FEATURE_TAG_PETITE_CAPITALS_FROM_CAPITALS + + + + Turns capital characters into small capitals. It is generally used for words which would otherwise be set in all caps, such as acronyms, but which are desired in small-cap form to avoid disrupting the flow of text. Equivalent OpenType tag: 'c2sc' + + DWRITE_FONT_FEATURE_TAG_SMALL_CAPITALS_FROM_CAPITALS + + + + In specified situations, replaces default glyphs with alternate forms which provide better joining behavior. Used in script typefaces which are designed to have some or all of their glyphs join. Equivalent OpenType tag: 'calt' + + DWRITE_FONT_FEATURE_TAG_CONTEXTUAL_ALTERNATES + + + + Shifts various punctuation marks up to a position that works better with all-capital sequences or sets of lining figures; also changes oldstyle figures to lining figures. By default, glyphs in a text face are designed to work with lowercase characters. Some characters should be shifted vertically to fit the higher visual center of all-capital or lining text. Also, lining figures are the same height (or close to it) as capitals, and fit much better with all-capital text. Equivalent OpenType tag: 'case' + + DWRITE_FONT_FEATURE_TAG_CASE_SENSITIVE_FORMS + + + + To minimize the number of glyph alternates, it is sometimes desired to decompose a character into two glyphs. Additionally, it may be preferable to compose two characters into a single glyph for better glyph processing. This feature permits such composition/decomposition. The feature should be processed as the first feature processed, and should be processed only when it is called. Equivalent OpenType tag: 'ccmp' + + DWRITE_FONT_FEATURE_TAG_GLYPH_COMPOSITION_DECOMPOSITION + + + + Replaces a sequence of glyphs with a single glyph which is preferred for typographic purposes. Unlike other ligature features, clig specifies the context in which the ligature is recommended. This capability is important in some script designs and for swash ligatures. Equivalent OpenType tag: 'clig' + + DWRITE_FONT_FEATURE_TAG_CONTEXTUAL_LIGATURES + + + + Globally adjusts inter-glyph spacing for all-capital text. Most typefaces contain capitals and lowercase characters, and the capitals are positioned to work with the lowercase. When capitals are used for words, they need more space between them for legibility and esthetics. This feature would not apply to monospaced designs. Of course the user may want to override this behavior in order to do more pronounced letterspacing for esthetic reasons. Equivalent OpenType tag: 'cpsp' + + DWRITE_FONT_FEATURE_TAG_CAPITAL_SPACING + + + + Replaces default character glyphs with corresponding swash glyphs in a specified context. Note that there may be more than one swash alternate for a given character. Equivalent OpenType tag: 'cswh' + + DWRITE_FONT_FEATURE_TAG_CONTEXTUAL_SWASH + + + + In cursive scripts like Arabic, this feature cursively positions adjacent glyphs. Equivalent OpenType tag: 'curs' + + DWRITE_FONT_FEATURE_TAG_CURSIVE_POSITIONING + + + + Replaces a sequence of glyphs with a single glyph which is preferred for typographic purposes. This feature covers those ligatures which may be used for special effect, at the user's preference. Equivalent OpenType tag: 'dlig' + + DWRITE_FONT_FEATURE_TAG_DEFAULT + + + + Replaces standard forms in Japanese fonts with corresponding forms preferred by typographers. For example, a user would invoke this feature to replace kanji character U+5516 with U+555E. + Equivalent OpenType tag: 'expt' + + DWRITE_FONT_FEATURE_TAG_DISCRETIONARY_LIGATURES + + + + Replaces figures separated by a slash with 'common' (diagonal) fractions. Equivalent OpenType tag: 'frac' + + DWRITE_FONT_FEATURE_TAG_EXPERT_FORMS + + + + Replaces glyphs set on other widths with glyphs set on full (usually em) widths. In a CJKV font, this may include "lower ASCII" Latin characters and various symbols. In a European font, this feature replaces proportionally-spaced glyphs with monospaced glyphs, which are generally set on widths of 0.6 em. For example, a user may invoke this feature in a Japanese font to get full monospaced Latin glyphs instead of the corresponding proportionally-spaced versions. Equivalent OpenType tag: 'fwid' + + DWRITE_FONT_FEATURE_TAG_FRACTIONS + + + + Produces the half forms of consonants in Indic scripts. For example, in Hindi (Devanagari script), the conjunct KKa, obtained by doubling the Ka, is denoted with a half form of Ka followed by the full form. Equivalent OpenType tag: 'half' + + DWRITE_FONT_FEATURE_TAG_FULL_WIDTH + + + + Produces the halant forms of consonants in Indic scripts. For example, in Sanskrit (Devanagari script), syllable final consonants are frequently required in their halant form. Equivalent OpenType tag: 'haln' + + DWRITE_FONT_FEATURE_TAG_HALF_FORMS + + + + Respaces glyphs designed to be set on full-em widths, fitting them onto half-em widths. This differs from hwid in that it does not substitute new glyphs. Equivalent OpenType tag: 'halt' + + DWRITE_FONT_FEATURE_TAG_HALANT_FORMS + + + + Replaces the default (current) forms with the historical alternates. While some ligatures are also used for historical effect, this feature deals only with single characters. Some fonts include the historical forms as alternates, so they can be used for a 'period' effect. Equivalent OpenType tag: 'hist' + + DWRITE_FONT_FEATURE_TAG_ALTERNATE_HALF_WIDTH + + + + Replaces standard kana with forms that have been specially designed for only horizontal writing. This is a typographic optimization for improved fit and more even color. Equivalent OpenType tag: 'hkna' + + DWRITE_FONT_FEATURE_TAG_HISTORICAL_FORMS + + + + Replaces the default (current) forms with the historical alternates. Some ligatures were in common use in the past, but appear anachronistic today. Some fonts include the historical forms as alternates, so they can be used for a 'period' effect. Equivalent OpenType tag: 'hlig' + + DWRITE_FONT_FEATURE_TAG_HORIZONTAL_KANA_ALTERNATES + + + + Replaces glyphs on proportional widths, or fixed widths other than half an em, with glyphs on half-em (en) widths. Many CJKV fonts have glyphs which are set on multiple widths; this feature selects the half-em version. There are various contexts in which this is the preferred behavior, including compatibility with older desktop documents. Equivalent OpenType tag: 'hwid' + + DWRITE_FONT_FEATURE_TAG_HISTORICAL_LIGATURES + + + + Used to access the JIS X 0212-1990 glyphs for the cases when the JIS X 0213:2004 form is encoded. The JIS X 0212-1990 (aka, "Hojo Kanji") and JIS X 0213:2004 character sets overlap significantly. In some cases their prototypical glyphs differ. When building fonts that support both JIS X 0212-1990 and JIS X 0213:2004 (such as those supporting the Adobe-Japan 1-6 character collection), it is recommended that JIS X 0213:2004 forms be the preferred encoded form. Equivalent OpenType tag: 'hojo' + + DWRITE_FONT_FEATURE_TAG_HALF_WIDTH + + + + The National Language Council (NLC) of Japan has defined new glyph shapes for a number of JIS characters, which were incorporated into JIS X 0213:2004 as new prototypical forms. The 'jp04' feature is A subset of the 'nlck' feature, and is used to access these prototypical glyphs in a manner that maintains the integrity of JIS X 0213:2004. Equivalent OpenType tag: 'jp04' + + DWRITE_FONT_FEATURE_TAG_HOJO_KANJI_FORMS + + + + Replaces default (JIS90) Japanese glyphs with the corresponding forms from the JIS C 6226-1978 (JIS78) specification. Equivalent OpenType tag: 'jp78' + + DWRITE_FONT_FEATURE_TAG_JIS04_FORMS + + + + Replaces default (JIS90) Japanese glyphs with the corresponding forms from the JIS X 0208-1983 (JIS83) specification. Equivalent OpenType tag: 'jp83' + + DWRITE_FONT_FEATURE_TAG_JIS78_FORMS + + + + Replaces Japanese glyphs from the JIS78 or JIS83 specifications with the corresponding forms from the JIS X 0208-1990 (JIS90) specification. Equivalent OpenType tag: 'jp90' + + DWRITE_FONT_FEATURE_TAG_JIS83_FORMS + + + + Adjusts amount of space between glyphs, generally to provide optically consistent spacing between glyphs. Although a well-designed typeface has consistent inter-glyph spacing overall, some glyph combinations require adjustment for improved legibility. Besides standard adjustment in the horizontal direction, this feature can supply size-dependent kerning data via device tables, "cross-stream" kerning in the Y text direction, and adjustment of glyph placement independent of the advance adjustment. Note that this feature may apply to runs of more than two glyphs, and would not be used in monospaced fonts. Also note that this feature does not apply to text set vertically. Equivalent OpenType tag: 'kern' + + DWRITE_FONT_FEATURE_TAG_JIS90_FORMS + + + + Replaces a sequence of glyphs with a single glyph which is preferred for typographic purposes. This feature covers the ligatures which the designer/manufacturer judges should be used in normal conditions. Equivalent OpenType tag: 'liga' + + DWRITE_FONT_FEATURE_TAG_KERNING + + + + Changes selected figures from oldstyle to the default lining form. For example, a user may invoke this feature in order to get lining figures, which fit better with all-capital text. This feature overrides results of the Oldstyle Figures feature (onum). Equivalent OpenType tag: 'lnum' + + DWRITE_FONT_FEATURE_TAG_STANDARD_LIGATURES + + + + Enables localized forms of glyphs to be substituted for default forms. Many scripts used to write multiple languages over wide geographical areas have developed localized variant forms of specific letters, which are used by individual literary communities. For example, a number of letters in the Bulgarian and Serbian alphabets have forms distinct from their Russian counterparts and from each other. In some cases the localized form differs only subtly from the script 'norm', in others the forms are radically distinct. Equivalent OpenType tag: 'locl' + + DWRITE_FONT_FEATURE_TAG_LINING_FIGURES + + + + Positions mark glyphs with respect to base glyphs. For example, in Arabic script positioning the Hamza above the Yeh. Equivalent OpenType tag: 'mark' + + DWRITE_FONT_FEATURE_TAG_LOCALIZED_FORMS + + + + Replaces standard typographic forms of Greek glyphs with corresponding forms commonly used in mathematical notation (which are a subset of the Greek alphabet). Equivalent OpenType tag: 'mgrk' + + DWRITE_FONT_FEATURE_TAG_MARK_POSITIONING + + + + Positions marks with respect to other marks. Required in various non-Latin scripts like Arabic. For example, in Arabic, the ligaturised mark Ha with Hamza above it can also be obtained by positioning these marks relative to one another. Equivalent OpenType tag: 'mkmk' + + DWRITE_FONT_FEATURE_TAG_MATHEMATICAL_GREEK + + + + Replaces default glyphs with various notational forms (such as glyphs placed in open or solid circles, squares, parentheses, diamonds or rounded boxes). In some cases an annotation form may already be present, but the user may want a different one. Equivalent OpenType tag: 'nalt' + + DWRITE_FONT_FEATURE_TAG_MARK_TO_MARK_POSITIONING + + + + Used to access glyphs made from glyph shapes defined by the National Language Council (NLC) of Japan for a number of JIS characters in 2000. Equivalent OpenType tag: 'nlck' + + DWRITE_FONT_FEATURE_TAG_ALTERNATE_ANNOTATION_FORMS + + + + Changes selected figures from the default lining style to oldstyle form. For example, a user may invoke this feature to get oldstyle figures, which fit better into the flow of normal upper- and lowercase text. This feature overrides results of the Lining Figures feature (lnum). Equivalent OpenType tag: 'onum' + + DWRITE_FONT_FEATURE_TAG_NLC_KANJI_FORMS + + + + Replaces default alphabetic glyphs with the corresponding ordinal forms for use after figures. One exception to the follows-a-figure rule is the numero character (U+2116), which is actually a ligature substitution, but is best accessed through this feature. Equivalent OpenType tag: 'ordn' + + DWRITE_FONT_FEATURE_TAG_OLD_STYLE_FIGURES + + + + Respaces glyphs designed to be set on full-em widths, fitting them onto individual (more or less proportional) horizontal widths. This differs from pwid in that it does not substitute new glyphs (GPOS, not GSUB feature). The user may prefer the monospaced form, or may simply want to ensure that the glyph is well-fit and not rotated in vertical setting (Latin forms designed for proportional spacing would be rotated). Equivalent OpenType tag: 'palt' + + DWRITE_FONT_FEATURE_TAG_ORDINALS + + + + Turns lowercase characters into petite capitals. Forms related to petite capitals, such as specially designed figures, may be included. Some fonts contain an additional size of capital letters, shorter than the regular smallcaps and it is referred to as petite caps. Such forms are most likely to be found in designs with a small lowercase x-height, where they better harmonise with lowercase text than the taller smallcaps (for examples of petite caps, see the Emigre type families Mrs Eaves and Filosofia). Equivalent OpenType tag: 'pcap' + + DWRITE_FONT_FEATURE_TAG_PROPORTIONAL_ALTERNATE_WIDTH + + + + Replaces figure glyphs set on uniform (tabular) widths with corresponding glyphs set on glyph-specific (proportional) widths. Tabular widths will generally be the default, but this cannot be safely assumed. Of course this feature would not be present in monospaced designs. Equivalent OpenType tag: 'pnum' + + DWRITE_FONT_FEATURE_TAG_PETITE_CAPITALS + + + + Replaces glyphs set on uniform widths (typically full or half-em) with proportionally spaced glyphs. The proportional variants are often used for the Latin characters in CJKV fonts, but may also be used for Kana in Japanese fonts. Equivalent OpenType tag: 'pwid' + + DWRITE_FONT_FEATURE_TAG_PROPORTIONAL_FIGURES + + + + Replaces glyphs on other widths with glyphs set on widths of one quarter of an em (half an en). The characters involved are normally figures and some forms of punctuation. Equivalent OpenType tag: 'qwid' + + DWRITE_FONT_FEATURE_TAG_PROPORTIONAL_WIDTHS + + + + Replaces a sequence of glyphs with a single glyph which is preferred for typographic purposes. This feature covers those ligatures, which the script determines as required to be used in normal conditions. This feature is important for some scripts to ensure correct glyph formation. Equivalent OpenType tag: 'rlig' + + DWRITE_FONT_FEATURE_TAG_QUARTER_WIDTHS + + + + Identifies glyphs in the font which have been designed for "ruby", from the old typesetting term for four-point-sized type. Japanese typesetting often uses smaller kana glyphs, generally in superscripted form, to clarify the meaning of kanji which may be unfamiliar to the reader. Equivalent OpenType tag: 'ruby' + + DWRITE_FONT_FEATURE_TAG_REQUIRED_LIGATURES + + + + Replaces the default forms with the stylistic alternates. Many fonts contain alternate glyph designs for a purely esthetic effect; these don't always fit into a clear category like swash or historical. As in the case of swash glyphs, there may be more than one alternate form. Equivalent OpenType tag: 'salt' + + DWRITE_FONT_FEATURE_TAG_RUBY_NOTATION_FORMS + + + + Replaces lining or oldstyle figures with inferior figures (smaller glyphs which sit lower than the standard baseline, primarily for chemical or mathematical notation). May also replace lowercase characters with alphabetic inferiors. Equivalent OpenType tag: 'sinf' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_ALTERNATES + + + + Turns lowercase characters into small capitals. This corresponds to the common SC font layout. It is generally used for display lines set in Large & small caps, such as titles. Forms related to small capitals, such as oldstyle figures, may be included. Equivalent OpenType tag: 'smcp' + + DWRITE_FONT_FEATURE_TAG_SCIENTIFIC_INFERIORS + + + + Replaces 'traditional' Chinese or Japanese forms with the corresponding 'simplified' forms. Equivalent OpenType tag: 'smpl' + + DWRITE_FONT_FEATURE_TAG_SMALL_CAPITALS + + + + In addition to, or instead of, stylistic alternatives of individual glyphs (see 'salt' feature), some fonts may contain sets of stylistic variant glyphs corresponding to portions of the character set, such as multiple variants for lowercase letters in a Latin font. Glyphs in stylistic sets may be designed to harmonise visually, interract in particular ways, or otherwise work together. Examples of fonts including stylistic sets are Zapfino Linotype and Adobe's Poetica. Individual features numbered sequentially with the tag name convention 'ss01' 'ss02' 'ss03' . 'ss20' provide a mechanism for glyphs in these sets to be associated via GSUB lookup indexes to default forms and to each other, and for users to select from available stylistic sets Equivalent OpenType tag: 'ss01' + + DWRITE_FONT_FEATURE_TAG_SIMPLIFIED_FORMS + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss02' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss03' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_2 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss04' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_3 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss05' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_4 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss06' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_5 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss07' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_6 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss08' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_7 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss09' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_8 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss10' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_9 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss11' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_10 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss12' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_11 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss13' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_12 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss14' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_13 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss15' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_14 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss16' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_15 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss17' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_16 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss18' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_17 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss19' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_18 + + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. Equivalent OpenType tag: 'ss20' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_19 + + + + May replace a default glyph with a subscript glyph, or it may combine a glyph substitution with positioning adjustments for proper placement. Equivalent OpenType tag: 'subs' + + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_20 + + + + Replaces lining or oldstyle figures with superior figures (primarily for footnote indication), and replaces lowercase letters with superior letters (primarily for abbreviated French titles). Equivalent OpenType tag: 'sups' + + DWRITE_FONT_FEATURE_TAG_SUBSCRIPT + + + + Replaces default character glyphs with corresponding swash glyphs. Note that there may be more than one swash alternate for a given character. Equivalent OpenType tag: 'swsh' + + DWRITE_FONT_FEATURE_TAG_SUPERSCRIPT + + + + Replaces the default glyphs with corresponding forms designed specifically for titling. These may be all-capital and/or larger on the body, and adjusted for viewing at larger sizes. Equivalent OpenType tag: 'titl' + + DWRITE_FONT_FEATURE_TAG_SWASH + + + + Replaces 'simplified' Japanese kanji forms with the corresponding 'traditional' forms. This is equivalent to the Traditional Forms feature, but explicitly limited to the traditional forms considered proper for use in personal names (as many as 205 glyphs in some fonts). Equivalent OpenType tag: 'tnam' + + DWRITE_FONT_FEATURE_TAG_TITLING + + + + Replaces figure glyphs set on proportional widths with corresponding glyphs set on uniform (tabular) widths. Tabular widths will generally be the default, but this cannot be safely assumed. Of course this feature would not be present in monospaced designs. Equivalent OpenType tag: 'tnum' + + DWRITE_FONT_FEATURE_TAG_TRADITIONAL_NAME_FORMS + + + + Replaces 'simplified' Chinese hanzi or Japanese kanji forms with the corresponding 'traditional' forms. Equivalent OpenType tag: 'trad' + + DWRITE_FONT_FEATURE_TAG_TABULAR_FIGURES + + + + Replaces glyphs on other widths with glyphs set on widths of one third of an em. The characters involved are normally figures and some forms of punctuation. Equivalent OpenType tag: 'twid' + + DWRITE_FONT_FEATURE_TAG_TRADITIONAL_FORMS + + + + Maps upper- and lowercase letters to a mixed set of lowercase and small capital forms, resulting in a single case alphabet (for an example of unicase, see the Emigre type family Filosofia). The letters substituted may vary from font to font, as appropriate to the design. If aligning to the x-height, smallcap glyphs may be substituted, or specially designed unicase forms might be used. Substitutions might also include specially designed figures. + Equivalent OpenType tag: 'unic' + + DWRITE_FONT_FEATURE_TAG_THIRD_WIDTHS + + + + Allows the user to change from the default 0 to a slashed form. Some fonts contain both a default form of zero, and an alternative form which uses a diagonal slash through the counter. Especially in condensed designs, it can be difficult to distinguish between 0 and O (zero and capital O) in any situation where capitals and lining figures may be arbitrarily mixed. Equivalent OpenType tag: 'zero' + + DWRITE_FONT_FEATURE_TAG_UNICASE + + + + No documentation. + + DWRITE_FONT_FEATURE_TAG_SLASHED_ZERO + + + + Indicates additional shaping requirements for text. + + DWRITE_SCRIPT_SHAPES + + + + Indicates that there is no additional shaping requirements for text. Text is shaped with the writing system default behavior. + + DWRITE_SCRIPT_SHAPES_DEFAULT + + + + Indicates that text should leave no visible control or format control characters. + + DWRITE_SCRIPT_SHAPES_NO_VISUAL + + + + Indicates the condition at the edges of inline object or text used to determine line-breaking behavior. + + DWRITE_BREAK_CONDITION + + + + Indicates whether a break is allowed by determining the condition of the neighboring text span or inline object. + + DWRITE_BREAK_CONDITION_NEUTRAL + + + + Indicates that a line break is allowed, unless overruled by the condition of the neighboring text span or inline object, either prohibited by a "may not break" condition or forced by a "must break" condition. + + DWRITE_BREAK_CONDITION_CAN_BREAK + + + + Indicates that there should be no line break, unless overruled by a "must break" condition from the neighboring text span or inline object. + + DWRITE_BREAK_CONDITION_MAY_NOT_BREAK + + + + Indicates that the line break must happen, regardless of the condition of the adjacent text span or inline object. + + DWRITE_BREAK_CONDITION_MUST_BREAK + + + + Specifies how to apply number substitution on digits and related punctuation. + + DWRITE_NUMBER_SUBSTITUTION_METHOD + + + + Specifies that the substitution method should be determined based on the LOCALE_IDIGITSUBSTITUTION value of the specified text culture. + + DWRITE_NUMBER_SUBSTITUTION_METHOD_FROM_CULTURE + + + + If the culture is Arabic or Persian, specifies that the number shapes depend on the context. Either traditional or nominal number shapes are used, depending on the nearest preceding strong character or (if there is none) the reading direction of the paragraph. + + DWRITE_NUMBER_SUBSTITUTION_METHOD_CONTEXTUAL + + + + Specifies that code points 0x30-0x39 are always rendered as nominal numeral shapes (ones of the European number), that is, no substitution is performed. + + DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE + + + + Specifies that numbers are rendered using the national number shapes as specified by the LOCALE_SNATIVEDIGITS value of the specified text culture. + + DWRITE_NUMBER_SUBSTITUTION_METHOD_NATIONAL + + + + Specifies that numbers are rendered using the traditional shapes for the specified culture. For most cultures, this is the same as NativeNational. However, NativeNational results in Latin numbers for some Arabic cultures, whereasDWRITE_NUMBER_SUBSTITUTION_METHOD_TRADITIONAL results in arabic numbers for all Arabic cultures. + + DWRITE_NUMBER_SUBSTITUTION_METHOD_TRADITIONAL + + + + Identifies a type of alpha texture. + + + An alpha texture is a bitmap of alpha values, each representing opacity of a pixel or subpixel. + + DWRITE_TEXTURE_TYPE + + + + Specifies an alpha texture for aliased text rendering (that is, each pixel is either fully opaque or fully transparent), with one byte per pixel. + + DWRITE_TEXTURE_ALIASED_1x1 + + + + Specifies an alpha texture for ClearType text rendering, with three bytes per pixel in the horizontal dimension and one byte per pixel in the vertical dimension. + + DWRITE_TEXTURE_CLEARTYPE_3x1 + + + + DWrite Functions. + + + + + Load DLLs and bind functions + + + + + Creates a DirectWrite factory object that is used for subsequent creation of individual DirectWrite objects. + + + This function creates a {{DirectWrite}} factory object that is used for subsequent creation of individual DirectWrite objects. DirectWrite factory contains internal state data such as font loader registration and cached font data. In most cases it is recommended you use the shared factory object, because it allows multiple components that use DirectWrite to share internal DirectWrite state data, and thereby reduce memory usage. However, there are cases when it is desirable to reduce the impact of a component, such as a plug-in from an untrusted source, on the rest of the process, by sandboxing and isolating it from the rest of the process components. In such cases, it is recommended you use an isolated factory for the sandboxed component. The following example shows how to create a shared {{DirectWrite}} factory. + if (SUCCEEDED(hr)) + { hr = DWriteCreateFactory( DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), reinterpret_cast<IUnknown**>(&pDWriteFactory_) ); + } + + + A value that specifies whether the factory object will be shared or isolated. + A GUID value that identifies the DirectWrite factory interface, such as __uuidof(IDWriteFactory). + An address of a reference to the newly created DirectWrite factory object. + If the function succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT DWriteCreateFactory([In] DWRITE_FACTORY_TYPE factoryType,[In] GUID* iid,[Out] IUnknown** factory) + + + + A built-in implementation of the interface, that operates on local font files + and exposes local font file information from the font file reference key. Font file references created using {{CreateFontFileReference}} use this font file loader. + + IDWriteLocalFontFileLoader + + + + Initializes a new instance of the class. + + The native pointer. + + + + Obtains the length of the absolute file path from the font file reference key. + + Font file reference key that uniquely identifies the local font file within the scope of the font loader being used. + Size of font file reference key in bytes. + Length of the file path string, not including the terminated NULL character. + HRESULT IDWriteLocalFontFileLoader::GetFilePathLengthFromKey([In, Buffer] const void* fontFileReferenceKey,[None] int fontFileReferenceKeySize,[Out] int* filePathLength) + + + + Obtains the absolute font file path from the font file reference key. + + The font file reference key that uniquely identifies the local font file within the scope of the font loader being used. + The size of font file reference key in bytes. + The character array that receives the local file path. + The length of the file path character array. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteLocalFontFileLoader::GetFilePathFromKey([In, Buffer] const void* fontFileReferenceKey,[None] int fontFileReferenceKeySize,[Out, Buffer] wchar_t* filePath,[None] int filePathSize) + + + + Obtains the last write time of the file from the font file reference key. + + The font file reference key that uniquely identifies the local font file within the scope of the font loader being used. + The size of font file reference key in bytes. + The time of the last font file modification. + HRESULT IDWriteLocalFontFileLoader::GetLastWriteTimeFromKey([In, Buffer] const void* fontFileReferenceKey,[None] int fontFileReferenceKeySize,[Out] __int64* lastWriteTime) + + + + Represents a list of fonts. + + IDWriteFontList + + + + Initializes a new instance of the class. + + The native pointer. + + + + Gets the font collection that contains the fonts in the font list. + + When this method returns, contains the address of a reference to the current object. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontList::GetFontCollection([Out] IDWriteFontCollection** fontCollection) + + + + Gets the number of fonts in the font list. + + The number of fonts in the font list. + int IDWriteFontList::GetFontCount() + + + + Gets a font given its zero-based index. + + Zero-based index of the font in the font list. + When this method returns, contains the address of a reference to the newly created object. + HRESULT IDWriteFontList::GetFont([None] int index,[Out] IDWriteFont** font) + + + + Gets the font collection that contains the fonts in the font list. + + HRESULT IDWriteFontList::GetFontCollection([Out] IDWriteFontCollection** fontCollection) + + + + Gets the number of fonts in the font list. + + int IDWriteFontList::GetFontCount() + + + + Represents a family of related fonts. + + IDWriteFontFamily + + + + Initializes a new instance of the class. + + The native pointer. + + + + Creates a localized strings object that contains the family names for the font family, indexed by locale name. + + + The following example shows how to get the font family name from a object. + IDWriteLocalizedStrings* pFamilyNames = NULL; // Get a list of localized strings for the family name. + if (SUCCEEDED(hr)) + { hr = pFontFamily->GetFamilyNames(&pFamilyNames); + } UINT32 index = 0; + BOOL exists = false; wchar_t localeName[LOCALE_NAME_MAX_LENGTH]; if (SUCCEEDED(hr)) + { // Get the default locale for this user. int defaultLocaleSuccess = GetUserDefaultLocaleName(localeName, LOCALE_NAME_MAX_LENGTH); // If the default locale is returned, find that locale name, otherwise use "en-us". if (defaultLocaleSuccess) { hr = pFamilyNames->FindLocaleName(localeName, &index, &exists); } if (SUCCEEDED(hr) && !exists) // if the above find did not find a match, retry with US English { hr = pFamilyNames->FindLocaleName(L"en-us", &index, &exists); } + } // If the specified locale doesn't exist, select the first on the list. + if (!exists) index = 0; UINT32 length = 0; // Get the string length. + if (SUCCEEDED(hr)) + { hr = pFamilyNames->GetStringLength(index, &length); + } // Allocate a string big enough to hold the name. + wchar_t* name = new (std::nothrow) wchar_t[length+1]; + if (name == NULL) + { hr = E_OUTOFMEMORY; + } // Get the family name. + if (SUCCEEDED(hr)) + { hr = pFamilyNames->GetString(index, name, length+1); + } + + + The address of a reference to the newly created object. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT IDWriteFontFamily::GetFamilyNames([Out] IDWriteLocalizedStrings** names) + + + + Gets the font that best matches the specified properties. + + A value that is used to match a requested font weight. + A value that is used to match a requested font stretch. + A value that is used to match a requested font style. + When this method returns, contains the address of a reference to the newly created object. + HRESULT IDWriteFontFamily::GetFirstMatchingFont([None] DWRITE_FONT_WEIGHT weight,[None] DWRITE_FONT_STRETCH stretch,[None] DWRITE_FONT_STYLE style,[Out] IDWriteFont** matchingFont) + + + + Gets a list of fonts in the font family ranked in order of how well they match the specified properties. + + A value that is used to match a requested font weight. + A value that is used to match a requested font stretch. + A value that is used to match a requested font style. + An address of a reference to the newly created object. + HRESULT IDWriteFontFamily::GetMatchingFonts([None] DWRITE_FONT_WEIGHT weight,[None] DWRITE_FONT_STRETCH stretch,[None] DWRITE_FONT_STYLE style,[Out] IDWriteFontList** matchingFonts) + + + + Creates a localized strings object that contains the family names for the font family, indexed by locale name. + + + The following example shows how to get the font family name from a object. + IDWriteLocalizedStrings* pFamilyNames = NULL; // Get a list of localized strings for the family name. + if (SUCCEEDED(hr)) + { hr = pFontFamily->GetFamilyNames(&pFamilyNames); + } UINT32 index = 0; + BOOL exists = false; wchar_t localeName[LOCALE_NAME_MAX_LENGTH]; if (SUCCEEDED(hr)) + { // Get the default locale for this user. int defaultLocaleSuccess = GetUserDefaultLocaleName(localeName, LOCALE_NAME_MAX_LENGTH); // If the default locale is returned, find that locale name, otherwise use "en-us". if (defaultLocaleSuccess) { hr = pFamilyNames->FindLocaleName(localeName, &index, &exists); } if (SUCCEEDED(hr) && !exists) // if the above find did not find a match, retry with US English { hr = pFamilyNames->FindLocaleName(L"en-us", &index, &exists); } + } // If the specified locale doesn't exist, select the first on the list. + if (!exists) index = 0; UINT32 length = 0; // Get the string length. + if (SUCCEEDED(hr)) + { hr = pFamilyNames->GetStringLength(index, &length); + } // Allocate a string big enough to hold the name. + wchar_t* name = new (std::nothrow) wchar_t[length+1]; + if (name == NULL) + { hr = E_OUTOFMEMORY; + } // Get the family name. + if (SUCCEEDED(hr)) + { hr = pFamilyNames->GetString(index, name, length+1); + } + + + HRESULT IDWriteFontFamily::GetFamilyNames([Out] IDWriteLocalizedStrings** names) + + + + The DWRITE_FONT_METRICS structure specifies the metrics that are applicable to all glyphs within the font face. + + DWRITE_FONT_METRICS + + + + The number of font design units per em unit. Font files use their own coordinate system of font design units. A font design unit is the smallest measurable unit in the em square, an imaginary square that is used to size and align glyphs. The concept of em square is used as a reference scale factor when defining font size and device transformation semantics. The size of one em square is also commonly used to compute the paragraph identation value. + + short designUnitsPerEm + + + + The ascent value of the font face in font design units. Ascent is the distance from the top of font character alignment box to the English baseline. + + short ascent + + + + The descent value of the font face in font design units. Descent is the distance from the bottom of font character alignment box to the English baseline. + + short descent + + + + The line gap in font design units. Recommended additional white space to add between lines to improve legibility. The recommended line spacing (baseline-to-baseline distance) is the sum of ascent, descent, and lineGap. The line gap is usually positive or zero but can be negative, in which case the recommended line spacing is less than the height of the character alignment box. + + short lineGap + + + + The cap height value of the font face in font design units. Cap height is the distance from the English baseline to the top of a typical English capital. Capital "H" is often used as a reference character for the purpose of calculating the cap height value. + + short capHeight + + + + The x-height value of the font face in font design units. x-height is the distance from the English baseline to the top of lowercase letter "x", or a similar lowercase character. + + short xHeight + + + + The underline position value of the font face in font design units. Underline position is the position of underline relative to the English baseline. The value is usually made negative in order to place the underline below the baseline. + + short underlinePosition + + + + The suggested underline thickness value of the font face in font design units. + + short underlineThickness + + + + The strikethrough position value of the font face in font design units. Strikethrough position is the position of strikethrough relative to the English baseline. The value is usually made positive in order to place the strikethrough above the baseline. + + short strikethroughPosition + + + + The suggested strikethrough thickness value of the font face in font design units. + + short strikethroughThickness + + + + Specifies the metrics of an individual glyph. The units depend on how the metrics are obtained. + + DWRITE_GLYPH_METRICS + + + + Specifies the X offset from the glyph origin to the left edge of the black box. The glyph origin is the current horizontal writing position. A negative value means the black box extends to the left of the origin (often true for lowercase italic 'f'). + + int leftSideBearing + + + + Specifies the X offset from the origin of the current glyph to the origin of the next glyph when writing horizontally. + + int advanceWidth + + + + Specifies the X offset from the right edge of the black box to the origin of the next glyph when writing horizontally. The value is negative when the right edge of the black box overhangs the layout box. + + int rightSideBearing + + + + Specifies the vertical offset from the vertical origin to the top of the black box. Thus, a positive value adds whitespace whereas a negative value means the glyph overhangs the top of the layout box. + + int topSideBearing + + + + Specifies the Y offset from the vertical origin of the current glyph to the vertical origin of the next glyph when writing vertically. Note that the term "origin" by itself denotes the horizontal origin. The vertical origin is different. Its Y coordinate is specified by verticalOriginY value, and its X coordinate is half the advanceWidth to the right of the horizontal origin. + + int advanceHeight + + + + Specifies the vertical distance from the bottom edge of the black box to the advance height. This is positive when the bottom edge of the black box is within the layout box, or negative when the bottom edge of black box overhangs the layout box. + + int bottomSideBearing + + + + Specifies the Y coordinate of a glyph's vertical origin, in the font's design coordinate system. The y coordinate of a glyph's vertical origin is the sum of the glyph's top side bearing and the top (that is, yMax) of the glyph's bounding box. + + int verticalOriginY + + + + The optional adjustment to a glyph's position. + + + An glyph offset changes the position of a glyph without affecting the pen position. Offsets are in logical, pre-transform units. + + DWRITE_GLYPH_OFFSET + + + + The offset in the advance direction of the run. A positive advance offset moves the glyph to the right (in pre-transform coordinates) if the run is left-to-right or to the left if the run is right-to-left. + + float advanceOffset + + + + The offset in the ascent direction, that is, the direction ascenders point. A positive ascender offset moves the glyph up (in pre-transform coordinates). A negative ascender offset moves the glyph down. + + float ascenderOffset + + + + The DWRITE_MATRIX structure specifies the graphics transform to be applied to rendered glyphs. + + DWRITE_MATRIX + + + + A value indicating the horizontal scaling / cosine of rotation. + + float m11 + + + + A value indicating the vertical shear / sine of rotation. + + float m12 + + + + A value indicating the horizontal shear / negative sine of rotation. + + float m21 + + + + A value indicating the vertical scaling / cosine of rotation. + + float m22 + + + + A value indicating the horizontal shift (always orthogonal regardless of rotation). + + float dx + + + + A value indicating the vertical shift (always orthogonal regardless of rotation.) + + float dy + + + + Contains a set of typographic features to be applied during text shaping. + + DWRITE_TYPOGRAPHIC_FEATURES + + + + A reference to a structure that specifies properties used to identify and execute typographic features in the font. + + DWRITE_FONT_FEATURE* features + + + + A value that indicates the number of features being applied to a font face. + + int featureCount + + + + Specifies the trimming option for text overflowing the layout box. + + DWRITE_TRIMMING + + + + A value that specifies the text granularity used to trim text overflowing the layout box. + + DWRITE_TRIMMING_GRANULARITY granularity + + + + A character code used as the delimiter that signals the beginning of the portion of text to be preserved. Most useful for path ellipsis, where the delimiter would be a slash. + + int delimiter + + + + A value that indicates how many occurrences of the delimiter to step back. + + int delimiterCount + + + + Stores the association of text and its writing system script, as well as some display attributes. + + DWRITE_SCRIPT_ANALYSIS + + + + The zero-based index representation of writing system script. + + short script + + + + A value that indicates additional shaping requirement of text. + + DWRITE_SCRIPT_SHAPES shapes + + + + Shaping output properties for an output glyph. + + DWRITE_SHAPING_TEXT_PROPERTIES + + + + Indicates that the glyph is shaped alone. + + short isShapedAlone + + + + Reserved for future use. + + short reserved + + + + Contains information about the width, thickness, offset, run height, reading direction, and flow direction of an underline. + + + All coordinates are in device independent pixels (DIPs). + + DWRITE_UNDERLINE + + + + A value that indicates the width of the underline, measured parallel to the baseline. + + float width + + + + A value that indicates the thickness of the underline, measured perpendicular to the baseline. + + float thickness + + + + A value that indicates the offset of the underline from the baseline. A positive offset represents a position below the baseline (away from the text) and a negative offset is above (toward the text). + + float offset + + + + A value that indicates the height of the tallest run where the underline is applied. + + float runHeight + + + + A value that indicates the reading direction of the text associated with the underline. This value is used to interpret whether the width value runs horizontally or vertically. + + DWRITE_READING_DIRECTION readingDirection + + + + A value that indicates the flow direction of the text associated with the underline. This value is used to interpret whether the thickness value advances top to bottom, left to right, or right to left. + + DWRITE_FLOW_DIRECTION flowDirection + + + + An array of characters which contains the locale of the text that the underline is being drawn under. For example, in vertical text, the underline belongs on the left for Chinese but on the right for Japanese. + + const wchar_t* localeName + + + + The measuring mode can be useful to the renderer to determine how underlines are rendered, such as rounding the thickness to a whole pixel in GDI-compatible modes. + + DWRITE_MEASURING_MODE measuringMode + + + + Contains information regarding the size and placement of strikethroughs. All coordinates are in device independent pixels (DIPs). + + DWRITE_STRIKETHROUGH + + + + A value that indicates the width of the strikethrough, measured parallel to the baseline. + + float width + + + + A value that indicates the thickness of the strikethrough, measured perpendicular to the baseline. + + float thickness + + + + A value that indicates the offset of the strikethrough from the baseline. A positive offset represents a position below the baseline and a negative offset is above. Typically, the offset will be negative. + + float offset + + + + Reading direction of the text associated with the strikethrough. This value is used to interpret whether the width value runs horizontally or vertically. + + DWRITE_READING_DIRECTION readingDirection + + + + Flow direction of the text associated with the strikethrough. This value is used to interpret whether the thickness value advances top to bottom, left to right, or right to left. + + DWRITE_FLOW_DIRECTION flowDirection + + + + An array of characters containing the locale of the text that is the strikethrough is being drawn over. + + const wchar_t* localeName + + + + The measuring mode can be useful to the renderer to determine how underlines are rendered, such as rounding the thickness to a whole pixel in GDI-compatible modes. + + DWRITE_MEASURING_MODE measuringMode + + + + Contains information about a formatted line of text. + + DWRITE_LINE_METRICS + + + + The number of text positions in the text line. This includes any trailing whitespace and newline characters. + + int length + + + + The number of whitespace positions at the end of the text line. Newline sequences are considered whitespace. + + int trailingWhitespaceLength + + + + The number of characters in the newline sequence at the end of the text line. If the count is zero, then the text line was either wrapped or it is the end of the text. + + int newlineLength + + + + The height of the text line. + + float height + + + + The distance from the top of the text line to its baseline. + + float baseline + + + + The line is trimmed. + + BOOL isTrimmed + + + + Contains information about a glyph cluster. + + DWRITE_CLUSTER_METRICS + + + + The total advance width of all glyphs in the cluster. + + float width + + + + The number of text positions in the cluster. + + short length + + + + Indicates whether a line can be broken right after the cluster. + + short canWrapLineAfter + + + + Indicates whether the cluster corresponds to a whitespace character. + + short isWhitespace + + + + Indicates whether the cluster corresponds to a newline character. + + short isNewline + + + + Indicates whether the cluster corresponds to a soft hyphen character. + + short isSoftHyphen + + + + Indicates whether the cluster is read from right to left. + + short isRightToLeft + + + + Reserved for future use. + + short padding + + + + Contains the metrics associated with text after layout. All coordinates are in device independent pixels (DIPs). + + DWRITE_TEXT_METRICS + + + + A value that indicates the left-most point of formatted text relative to the layout box, while excluding any glyph overhang. + + float left + + + + A value that indicates the top-most point of formatted text relative to the layout box, while excluding any glyph overhang. + + float top + + + + A value that indicates the width of the formatted text, while ignoring trailing whitespace at the end of each line. + + float width + + + + The width of the formatted text, taking into account the trailing whitespace at the end of each line. + + float widthIncludingTrailingWhitespace + + + + The height of the formatted text. The height of an empty string is set to the same value as that of the default font. + + float height + + + + The initial width given to the layout. It can be either larger or smaller than the text content width, depending on whether the text was wrapped. + + float layoutWidth + + + + Initial height given to the layout. Depending on the length of the text, it may be larger or smaller than the text content height. + + float layoutHeight + + + + The maximum reordering count of any line of text, used to calculate the most number of hit-testing boxes needed. If the layout has no bidirectional text, or no text at all, the minimum level is 1. + + int maxBidiReorderingDepth + + + + No documentation. + + int lineCount + + + + Contains properties describing the geometric measurement of an + application-defined inline object. + + DWRITE_INLINE_OBJECT_METRICS + + + + The width of the inline object. + + float width + + + + The height of the inline object. + + float height + + + + The distance from the top of the object to the point where it is lined up with the adjacent text. If the baseline is at the bottom, then baseline simply equals height. + + float baseline + + + + A Boolean flag that indicates whether the object is to be placed upright or alongside the text baseline for vertical text. + + BOOL supportsSideways + + + + Indicates how much any visible DIPs (device independent pixels) overshoot each side of the layout or inline objects. + + DWRITE_OVERHANG_METRICS + + + + The distance from the left-most visible DIP to its left alignment edge. + + float left + + + + The distance from the top-most visible DIP to its top alignment edge. + + float top + + + + The distance from the right-most visible DIP to its right alignment edge. + + float right + + + + The distance from the bottom-most visible DIP to its lower alignment edge. + + float bottom + + + + Describes the region obtained by a hit test. + + DWRITE_HIT_TEST_METRICS + + + + The first text position within the hit region. + + int textPosition + + + + The number of text positions within the hit region. + + int length + + + + The x-coordinate of the upper-left corner of the hit region. + + float left + + + + The y-coordinate of the upper-left corner of the hit region. + + float top + + + + The width of the hit region. + + float width + + + + The height of the hit region. + + float height + + + + The {{BIDI level}} of the text positions within the hit region. + + int bidiLevel + + + + true if the hit region contains text; otherwise, false. + + BOOL isText + + + + No documentation. + + BOOL isTrimmed + + + + Specifies how the alpha value of a bitmap or render target should be treated. + + + The D2D1_ALPHA_MODE enumeration is used with the enumeration to specify the alpha mode of a render target or bitmap. Different render targets and bitmaps support different alpha modes. For a list, see {{Supported Pixel Formats and Alpha Modes}}. The Differences Between Straight and Premultiplied Alpha When describing an RGBA color using straight alpha, the alpha value of the color is stored in the alpha channel. For example, to describe a red color that is 60% opaque, you'd use the following values: (255, 0, 0, 255 * 0.6) = (255, 0, 0, 153). The 255 value indicates full red, and 153 (which is 60 percent of 255) indicates that the color should have an opacity of 60 percent. When describing an RGBA color using premultiplied alpha, each color is multiplied by the alpha value: (255 * 0.6, 0 * 0.6, 0 * 0.6, 255 * 0.6) = (153, 0, 0, 153). Regardless of the alpha mode of the render target, values are always interpreted as straight alpha. For example, when specifying the color of an for use with a bitmap that uses the premultiplied alpha mode, you'd specify the color just as you would if the bitmap used straight alpha. When you paint with the brush, Direct2D translates the color to the destination format for you. Alpha Mode for Render Targets Regardless of the alpha mode setting, a render target's contents support transparency. For example, if you draw a partially transparent red rectangle with a render target with an alpha mode of D2D1_ALPHA_MODE_IGNORE, the rectangle will appear pink (if the background is white), as you might expect. If you draw a partially transparent red rectangle when the alpha mode is D2D1_ALPHA_MODE_PREMULTIPLIED, the rectangle will appear pink (assuming the background is white) and you can see through it to whatever is behind the render target. This is useful when using a to render to a transparent window or when using an compatible render target (a render targeted created by the {{CreateCompatibleRenderTarget}} method) to create a bitmap that supports transparency. ClearType and Alpha Modes If you specify an alpha mode other than D2D1_ALPHA_MODE_IGNORE for a render target, the text antialiasing mode automatically changes from {{D2D1_TEXT_ANTIALIAS_MODE CLEARTYPE}} to D2D1_TEXT_ANTIALIAS_MODE GRAYSCALE. (When you specify an alpha mode of D2D1_ALPHA_MODE_UNKNOWN, Direct2D sets the alpha for you depending on the type of render target. For a list of what the D2D1_ALPHA_MODE_UNKNOWN setting resolves to for each render target, see the {{Supported Pixel Formats and Alpha Modes}} overview.) You can use the {{SetTextAntialiasMode}} method to change the text antialias mode back to {{D2D1_TEXT_ANTIALIAS_MODE CLEARTYPE}}, but rendering ClearType text to a transparent surface can create unpredictable results. If you want to render ClearType text to an transparent render target, we recommend that you use one of the following two techniques. Use the {{PushAxisAlignedClip}} method to clip the render target to the area where the text will be rendered, then call the {{Clear}} method and specify an opaque color, then render your text. Use {{DrawRectangle}} to draw an opaque rectangle behind the area where the text will be rendered. + + D2D1_ALPHA_MODE + + + + The alpha value might not be meaningful. + + D2D1_ALPHA_MODE_UNKNOWN + + + + The alpha value has been premultiplied. Each color is first scaled by the alpha value. The alpha value itself is the same in both straight and premultiplied alpha. Typically, no color channel value is greater than the alpha channel value. If a color channel value in a premultiplied format is greater than the alpha channel, the standard source-over blending math results in an additive blend. + + D2D1_ALPHA_MODE_PREMULTIPLIED + + + + The alpha value has not been premultiplied. The alpha channel indicates the transparency of the color. + + D2D1_ALPHA_MODE_STRAIGHT + + + + The alpha value is ignored. + + D2D1_ALPHA_MODE_IGNORE + + + + Specifies which gamma is used for interpolation. + + + Interpolating in a linear gamma space (D2D1_GAMMA_1_0) can avoid changes in perceived brightness caused by the effect of gamma correction in spaces where the gamma is not 1.0, such as the default sRGB color space, where the gamma is 2.2. For an example of the differences between these two blending modes, consider the following illustration, which shows two gradients, each of which blends from red to blue to green: ? Illustration of two gradients from red to blue to green, blended by using sRGB gamma and linear-gamma ? The first gradient is interpolated linearly in the space of the render target (sRGB in this case), and one can see the dark bands between each color. The second gradient uses a gamma-correct linear interpolation, and thus does not exhibit the same variations in brightness. + + D2D1_GAMMA + + + + Interpolation is performed in the standard RGB (sRGB) gamma. + + D2D1_GAMMA_2_2 + + + + Interpolation is performed in the linear-gamma color space. + + D2D1_GAMMA_1_0 + + + + Describes whether an opacity mask contains graphics or text. Direct2D uses this information to determine which gamma space to use when blending the opacity mask. + + D2D1_OPACITY_MASK_CONTENT + + + + The opacity mask contains graphics. The opacity mask is blended in the gamma 2.2 color space. + + D2D1_OPACITY_MASK_CONTENT_GRAPHICS + + + + The opacity mask contains non-GDI text. The gamma space used for blending is obtained from the render target's text rendering parameters. (). + + D2D1_OPACITY_MASK_CONTENT_TEXT_NATURAL + + + + The opacity mask contains text rendered using the GDI-compatible rendering mode. The opacity mask is blended using the gamma for GDI rendering. + + D2D1_OPACITY_MASK_CONTENT_TEXT_GDI_COMPATIBLE + + + + Specifies how a brush paints areas outside of its normal content area. + + + For an , the brush's content is the brush's bitmap. For an , the brush's content area is the gradient axis. For an , the brush's content is the area within the gradient ellipse. For an example, see the {{Draw Extend Mode Example}}. + + D2D1_EXTEND_MODE + + + + Repeat the edge pixels of the brush's content for all regions outside the normal content area. + + D2D1_EXTEND_MODE_CLAMP + + + + Repeat the brush's content. + + D2D1_EXTEND_MODE_WRAP + + + + The same as D2D1_EXTEND_MODE_WRAP, except that alternate tiles of the brush's content are flipped. (The brush's normal content is drawn untransformed.) + + D2D1_EXTEND_MODE_MIRROR + + + + Specifies how the edges of nontext primitives are rendered. + + D2D1_ANTIALIAS_MODE + + + + Edges are antialiased using the Direct2D per-primitive method of high-quality antialiasing. + + D2D1_ANTIALIAS_MODE_PER_PRIMITIVE + + + + Objects are aliased in most cases. Objects are antialiased only when they are drawn to a render target created by the {{CreateDxgiSurfaceRenderTarget}} method and Direct3D multisampling has been enabled on the backing DirectX Graphics Infrastructure (DXGI) surface. + + D2D1_ANTIALIAS_MODE_ALIASED + + + + Describes the antialiasing mode used for drawing text. + + + This enumeration is used with the {{SetTextAntialiasMode}} of an to specify how text and glyphs are antialiased. By default, Direct2D renders text in ClearType mode. Factors that can downgrade the default quality to grayscale or aliased: If the value is DWRITE_RENDERING_MODE_ALIASED , then the default text antialiasing mode is aliased. To change the DirectWrite rendering mode of an , use the method. If the value is DWRITE_RENDERING_MODE_OUTLINE, then the default text antialiasing mode is grayscale. If the render target has an alpha channel and is not set to , then the default text antialiasing mode is grayscale. If is called without (and the corresponding {{PopLayer}} has not been called yet), then the default text antialiasing mode is grayscale. + + D2D1_TEXT_ANTIALIAS_MODE + + + + Use the system default. See Remarks. + + D2D1_TEXT_ANTIALIAS_MODE_DEFAULT + + + + Use ClearType antialiasing. + + D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE + + + + Use grayscale antialiasing. + + D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE + + + + Do not use antialiasing. + + D2D1_TEXT_ANTIALIAS_MODE_ALIASED + + + + Specifies the algorithm that is used when images are scaled or rotated. + + + To stretch an image, each pixel in the original image must be mapped to a group of pixels in the larger image. To shrink an image, groups of pixels in the original image must be mapped to single pixels in the smaller image. The effectiveness of the algorithms that perform these mappings determines the quality of a scaled image. Algorithms that produce higher-quality scaled images tend to require more processing time. D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR provides faster but lower-quality interpolation, while D2D1_BITMAP_INTERPOLATION_MODE_LINEAR provides higher-quality interpolation. + + D2D1_BITMAP_INTERPOLATION_MODE + + + + Use the exact color of the nearest bitmap pixel to the current rendering pixel. + + D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR + + + + Interpolate a color from the four bitmap pixels that are the nearest to the rendering pixel. + + D2D1_BITMAP_INTERPOLATION_MODE_LINEAR + + + + Specifies whether text snapping is suppressed or clipping to the layout rectangle is enabled. This enumeration allows a bitwise combination of its member values. + + D2D1_DRAW_TEXT_OPTIONS + + + + Text is not vertically snapped to pixel boundaries. This setting is recommended for text that is being animated. + + D2D1_DRAW_TEXT_OPTIONS_NO_SNAP + + + + Text is clipped to the layout rectangle. + + D2D1_DRAW_TEXT_OPTIONS_CLIP + + + + Text is vertically snapped to pixel boundaries and is not clipped to the layout rectangle. + + D2D1_DRAW_TEXT_OPTIONS_NONE + + + + Specifies whether an arc should be greater than 180 degrees. + + D2D1_ARC_SIZE + + + + An arc's sweep should be 180 degrees or less. + + D2D1_ARC_SIZE_SMALL + + + + An arc's sweep should be 180 degrees or greater. + + D2D1_ARC_SIZE_LARGE + + + + Describes the shape at the end of a line or segment. + + + The following illustration shows the available cap styles for lines or segments. The red portion of the line shows the extra area added by the line cap setting. ? Illustration of four cap styles ? + + D2D1_CAP_STYLE + + + + A cap that does not extend past the last point of the line. Comparable to cap used for objects other than lines. + + D2D1_CAP_STYLE_FLAT + + + + Half of a square that has a length equal to the line thickness. + + D2D1_CAP_STYLE_SQUARE + + + + A semicircle that has a diameter equal to the line thickness. + + D2D1_CAP_STYLE_ROUND + + + + An isosceles right triangle whose hypotenuse is equal in length to the thickness of the line. + + D2D1_CAP_STYLE_TRIANGLE + + + + Describes the sequence of dashes and gaps in a stroke. + + + The following illustration shows several available dash styles. For more information, see the {{Stroke Style Example}}. ? Illustration of available dash styles ? + + D2D1_DASH_STYLE + + + + A solid line with no breaks. + + D2D1_DASH_STYLE_SOLID + + + + A dash followed by a gap of equal length. The dash and the gap are each twice as long as the stroke thickness. The equivalent dash array for D2D1_DASH_STYLE_DASH is {2, 2}. + + D2D1_DASH_STYLE_DASH + + + + A dot followed by a longer gap. The equivalent dash array for D2D1_DASH_STYLE_DOT is {0, 2}. + + D2D1_DASH_STYLE_DOT + + + + A dash, followed by a gap, followed by a dot, followed by another gap. The equivalent dash array for D2D1_DASH_STYLE_DASH_DOT is {2, 2, 0, 2}. + + D2D1_DASH_STYLE_DASH_DOT + + + + A dash, followed by a gap, followed by a dot, followed by another gap, followed by another dot, followed by another gap. The equivalent dash array for D2D1_DASH_STYLE_DASH_DOT_DOT is {2, 2, 0, 2, 0, 2}. + + D2D1_DASH_STYLE_DASH_DOT_DOT + + + + The dash pattern is specified by an array of floating-point values. + + D2D1_DASH_STYLE_CUSTOM + + + + Describes the shape that joins two lines or segments. + + + A miter limit affects how sharp miter joins are allowed to be. If the line join style is D2D1_LINE_JOIN_MITER_OR_BEVEL, then the join will be mitered with regular angular vertices if it doesn't extend beyond the miter limit; otherwise, the line join will be beveled. The following illustration shows different line join settings for the same stroked path geometry. For more information, see {{Stroke Style Example}}. ? Illustration of line join settings ? + + D2D1_LINE_JOIN + + + + Regular angular vertices. + + D2D1_LINE_JOIN_MITER + + + + Beveled vertices. + + D2D1_LINE_JOIN_BEVEL + + + + Rounded vertices. + + D2D1_LINE_JOIN_ROUND + + + + Regular angular vertices unless the join would extend beyond the miter limit; otherwise, beveled vertices. + + D2D1_LINE_JOIN_MITER_OR_BEVEL + + + + Specifies the different methods by which two geometries can be combined. + + + The following illustration shows the different geometry combine modes. + ? Illustration of two geometries and the resulting shapes after various geometry combine modes ? + + D2D1_COMBINE_MODE + + + + The two regions are combined by taking the union of both. Given two geometries, A and B, the resulting geometry is geometry A + geometry B. + + D2D1_COMBINE_MODE_UNION + + + + The two regions are combined by taking their intersection. The new area consists of the overlapping region between the two geometries. + + D2D1_COMBINE_MODE_INTERSECT + + + + The two regions are combined by taking the area that exists in the first region but not the second and the area that exists in the second region but not the first. Given two geometries, A and B, the new region consists of (A-B) + (B-A). + + D2D1_COMBINE_MODE_XOR + + + + The second region is excluded from the first. Given two geometries, A and B, the area of geometry B is removed from the area of geometry A, producing a region that is A-B. + + D2D1_COMBINE_MODE_EXCLUDE + + + + Describes how one geometry object is spatially related to another geometry object. + + D2D1_GEOMETRY_RELATION + + + + The relationship between the two geometries cannot be determined. This value is never returned by any D2D method. + + D2D1_GEOMETRY_RELATION_UNKNOWN + + + + The two geometries do not intersect at all. + + D2D1_GEOMETRY_RELATION_DISJOINT + + + + The instance geometry is entirely contained by the passed-in geometry. + + D2D1_GEOMETRY_RELATION_IS_CONTAINED + + + + The instance geometry entirely contains the passed-in geometry. + + D2D1_GEOMETRY_RELATION_CONTAINS + + + + The two geometries overlap but neither completely contains the other. + + D2D1_GEOMETRY_RELATION_OVERLAP + + + + Specifies how a geometry is simplified to an . + + D2D1_GEOMETRY_SIMPLIFICATION_OPTION + + + + The output can contain cubic Bezier curves and line segments. + + D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES + + + + The output is flattened so that it contains only line segments. + + D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES + + + + Indicates whether a specific figure is filled or hollow. + + D2D1_FIGURE_BEGIN + + + + The figure is filled. + + D2D1_FIGURE_BEGIN_FILLED + + + + The figure is hollow. + + D2D1_FIGURE_BEGIN_HOLLOW + + + + Indicates whether a specific figure is open or closed. + + D2D1_FIGURE_END + + + + The figure is open. + + D2D1_FIGURE_END_OPEN + + + + The figure is closed. + + D2D1_FIGURE_END_CLOSED + + + + Indicates whether a segment should be stroked and whether the join between this segment and the previous one should be smooth. This enumeration allows a bitwise combination of its member values. + + D2D1_PATH_SEGMENT + + + + The segment is joined as specified by the interface, and it is stroked. + + D2D1_PATH_SEGMENT_NONE + + + + The segment is not stroked. + + D2D1_PATH_SEGMENT_FORCE_UNSTROKED + + + + The segment is always joined with the one preceding it using a round line join, regardless of which enumeration is specified by the interface. If this segment is the first segment and the figure is closed, a round line join is used to connect the closing segment with the first segment. If the figure is not closed, this setting has no effect on the first segment of the figure. If is called just before , the join between the closing segment and the last explicitly specified segment is affected. + + D2D1_PATH_SEGMENT_FORCE_ROUND_LINE_JOIN + + + + Defines the direction that an elliptical arc is drawn. + + D2D1_SWEEP_DIRECTION + + + + Arcs are drawn in a counterclockwise (negative-angle) direction. + + D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE + + + + Arcs are drawn in a clockwise (positive-angle) direction. + + D2D1_SWEEP_DIRECTION_CLOCKWISE + + + + Specifies how the intersecting areas of geometries or figures are combined to form the area of the composite geometry. + + + Use the D2D1_FILL_MODE enumeration when creating an with the {{CreateGeometryGroup}} method, or when modifying the fill mode of an with the method. Direct2D fills the interior of a path by using one of the two fill modes specified by this enumeration: D2D1_FILL_MODE_ALTERNATE (alternate) or D2D1_FILL_MODE_WINDING (winding). Because the modes determine how to fill the interior of a closed shape, all shapes are treated as closed when they are filled. If there is a gap in a segment in a shape, draw an imaginary line to close it. To see the difference between the winding and alternate fill modes, assume that you have four circles with the same center and a different radius, as shown in the following illustration. The first one has the radius of 25, the second 50, the third 75, and the fourth 100. ? Illustration of four concentric circles with different radius values ? The following illustration shows the shape filled by using the alternate fill mode. Notice that the center and third ring are not filled. This is because a ray drawn from any point in either of those two rings passes through an even number of segments. ? Illustration of concentric circles with the second and fourth rings filled ? The following illustration explains this process. ? Illustration of concentric circles with points in the second and third rings and two arbitrary rays extending from each point ? The following illustration shows how the same shape is filled when the winding fill mode is specified. ? Illustration of concentric circles with all rings filled ? Notice that all the rings are filled. This is because all the segments run in the same direction, so a ray drawn from any point will cross one or more segments, and the sum of the crossings will not equal zero. The following illustration explains this process. The red arrows represent the direction in which the segments are drawn and the black arrow represents an arbitrary ray that runs from a point in the innermost ring. Starting with a value of zero, for each segment that the ray crosses, a value of one is added for every clockwise intersection. All points lie in the fill region in this illustration, because the count does not equal zero. ? Illustration of concentric circles with a ray from within the first ring that crosses all four rings ? + + D2D1_FILL_MODE + + + + Determines whether a point is in the fill region by drawing a ray from that point to infinity in any direction, and then counting the number of path segments within the given shape that the ray crosses. If this number is odd, the point is in the fill region; if even, the point is outside the fill region. + + D2D1_FILL_MODE_ALTERNATE + + + + Determines whether a point is in the fill region of the path by drawing a ray from that point to infinity in any direction, and then examining the places where a segment of the shape crosses the ray. Starting with a count of zero, add one each time a segment crosses the ray from left to right and subtract one each time a path segment crosses the ray from right to left, as long as left and right are seen from the perspective of the ray. After counting the crossings, if the result is zero, then the point is outside the path. Otherwise, it is inside the path. + + D2D1_FILL_MODE_WINDING + + + + Specifies options that can be applied when a layer resource is applied to create a layer. + + + ClearType antialiasing must use the current contents of the render target to blend properly. When a pushed layer requests initializing for ClearType, Direct 2D copies the current contents of the render target into the layer so that ClearType antialiasing can be performed. Rendering ClearType text into a transparent layer does not produce the desired results. A small performance hit from re-copying content occurs when is called. + + D2D1_LAYER_OPTIONS + + + + The text in this layer does not use ClearType antialiasing. + + D2D1_LAYER_OPTIONS_NONE + + + + The layer renders correctly for ClearType text. If the render target is set to ClearType, the layer continues to render ClearType. If the render target is set to ClearType and this option is not specified, the render target will be set to render gray-scale until the layer is popped. The caller can override this default by calling {{SetTextAntialiasMode}} while within the layer. This flag is slightly slower than the default. + + D2D1_LAYER_OPTIONS_INITIALIZE_FOR_CLEARTYPE + + + + Describes whether a window is occluded. + + + If the window was occluded the last time {{EndDraw}} was called, the next time the render target calls {{CheckWindowState}}, it will return D2D1_WINDOW_STATE_OCCLUDED regardless of the current window state. If you want to use CheckWindowState to determine the current window state, you should call CheckWindowState after every EndDraw call and ignore its return value. This will ensure that your next call to CheckWindowState state will return the actual window state. + + D2D1_WINDOW_STATE + + + + The window is not occluded. + + D2D1_WINDOW_STATE_NONE + + + + The window is occluded. + + D2D1_WINDOW_STATE_OCCLUDED + + + + Describes whether a render target uses hardware or software rendering, or if Direct2D should select the rendering mode. + + + Not every render target supports hardware rendering. For more information, see the {{Render Targets Overview}}. + + D2D1_RENDER_TARGET_TYPE + + + + The render target uses hardware rendering, if available; otherwise, it uses software rendering. + + D2D1_RENDER_TARGET_TYPE_DEFAULT + + + + The render target uses software rendering only. + + D2D1_RENDER_TARGET_TYPE_SOFTWARE + + + + The render target uses hardware rendering only. + + D2D1_RENDER_TARGET_TYPE_HARDWARE + + + + Describes the minimum DirectX support required for hardware rendering by a render target. + + D2D1_FEATURE_LEVEL + + + + Direct2D determines whether the video card provides adequate hardware rendering support. + + D2D1_FEATURE_LEVEL_DEFAULT + + + + The video card must support DirectX 9. + + D2D1_FEATURE_LEVEL_9 + + + + The video card must support DirectX 10. + + D2D1_FEATURE_LEVEL_10 + + + + Describes how a render target is remoted and whether it should be GDI-compatible. This enumeration allows a bitwise combination of its member values. + + D2D1_RENDER_TARGET_USAGE + + + + The render target attempts to use Direct3D command-stream remoting and uses bitmap remoting if stream remoting fails. The render target is not GDI-compatible. + + D2D1_RENDER_TARGET_USAGE_NONE + + + + The render target renders content locally and sends it to the terminal services client as a bitmap. + + D2D1_RENDER_TARGET_USAGE_FORCE_BITMAP_REMOTING + + + + The render target can be used efficiently with GDI. + + D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE + + + + Describes how a render target behaves when it presents its content. This enumeration allows a bitwise combination of its member values. + + D2D1_PRESENT_OPTIONS + + + + The render target waits until the display refreshes to present and discards the frame upon presenting. + + D2D1_PRESENT_OPTIONS_NONE + + + + The render target does not discard the frame upon presenting. + + D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS + + + + The render target does not wait until the display refreshes to present. + + D2D1_PRESENT_OPTIONS_IMMEDIATELY + + + + Specifies additional features supportable by a compatible render target when it is created. This enumeration allows a bitwise combination of its member values. + + + Use this enumeration when creating a compatible render target with the {{CreateCompatibleRenderTarget}} method. For more information about compatible render targets, see the {{Render Targets Overview}}. The D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_GDI_COMPATIBLE option may only be requested if the parent render target was created with (for most render targets) or D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_GDI_COMPATIBLE (for render targets created by the {{CreateCompatibleRenderTarget}} method). + + D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS + + + + The render target supports no additional features. + + D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE + + + + The render target supports interoperability with the Windows Graphics Device Interface (GDI). + + D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_GDI_COMPATIBLE + + + + Specifies how a device context is initialized for GDI rendering when it is retrieved from the render target. + + + Use this enumeration with the method to specify how the device context is initialized for GDI rendering. + + D2D1_DC_INITIALIZE_MODE + + + + The current contents of the render target are copied to the device context when it is initialized. + + D2D1_DC_INITIALIZE_MODE_COPY + + + + The device context is cleared to transparent black when it is initialized. + + D2D1_DC_INITIALIZE_MODE_CLEAR + + + + Indicates the type of information provided by the {{Direct2D Debug Layer}}. + + + To receive debugging messages, you must install the {{Direct2D Debug Layer}}. + + D2D1_DEBUG_LEVEL + + + + Direct2D does not produce any debugging output. + + D2D1_DEBUG_LEVEL_NONE + + + + Direct2D sends error messages to the debug layer. + + D2D1_DEBUG_LEVEL_ERROR + + + + Direct2D sends error messages and warnings to the debug layer. + + D2D1_DEBUG_LEVEL_WARNING + + + + Direct2D sends error messages, warnings, and additional diagnostic information that can help improve performance to the debug layer. + + D2D1_DEBUG_LEVEL_INFORMATION + + + + Specifies whether Direct2D provides synchronization for an and the resources it creates, so that they may be safely accessed from multiple threads. + + + When you create a factory, you can specify whether it is multithreaded or singlethreaded. A singlethreaded factory provides no serialization against any other single threaded instance within Direct2D, so this mechanism provides a very large degree of scaling on the CPU. You can also create a multithreaded factory instance. In this case, the factory and all derived objects can be used from any thread, and each render target can be rendered to independently. Direct2D serializes calls to these objects, so a single multithreaded Direct2D instance won't scale as well on the CPU as many single threaded instances. However, the resources can be shared within the multithreaded instance. Note the qualifier "On the CPU": GPUs generally take advantage of fine-grained parallelism more so than CPUs. For example, multithreaded calls from the CPU might still end up being serialized when being sent to the GPU; however, a whole bank of pixel and vertex shaders will run in parallel to perform the rendering. + + D2D1_FACTORY_TYPE + + + + No synchronization is provided for accessing or writing to the factory or the objects it creates. If the factory or the objects are called from multiple threads, it is up to the application to provide access locking. + + D2D1_FACTORY_TYPE_SINGLE_THREADED + + + + Direct2D provides synchronization for accessing and writing to the factory and the objects it creates, enabling safe access from multiple threads. + + D2D1_FACTORY_TYPE_MULTI_THREADED + + + + D2D1 Functions. + + + + + Load DLLs and bind functions + + + + + Creates a factory object that can be used to create Direct2D resources. + + + The interface provides the starting point for Direct2D. In general, objects created from a single instance of a factory object can be used with other resources created from that instance, but not with resources created by other factory instances. + + The threading model of the factory and the resources it creates. + A reference to the IID of that is obtained by using __uuidof(ID2D1Factory). + The level of detail provided to the debugging layer. + When this method returns, contains the address to a reference to the new factory. + If the function succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT D2D1CreateFactory([In] D2D1_FACTORY_TYPE factoryType,[In] GUID* riid,[In, Optional] const D2D1_FACTORY_OPTIONS* pFactoryOptions,[Out] void** ppIFactory) + + + + Creates a rotation transformation that rotates by the specified angle about the specified point. + + + Rotation occurs in the plane of the 2-D surface. + + The clockwise rotation angle, in degrees. + The point about which to rotate. + When this method returns, contains the new rotation transformation. You must allocate storage for this parameter. + void D2D1MakeRotateMatrix([In] float angle,[In] D2D1_POINT_2F center,[Out] D2D1_MATRIX_3X2_F* matrix) + + + + Creates a skew transformation that has the specified x-axis angle, y-axis angle, and center point. + + The x-axis skew angle, which is measured in degrees counterclockwise from the y-axis. + The y-axis skew angle, which is measured in degrees counterclockwise from the x-axis. + The center point of the skew operation. + When this method returns, contains the rotation transformation. You must allocate storate for this parameter. + void D2D1MakeSkewMatrix([In] float angleX,[In] float angleY,[In] D2D1_POINT_2F center,[Out] D2D1_MATRIX_3X2_F* matrix) + + + + Indicates whether the specified matrix is invertible. + + The matrix to test. + BOOLtrue if the matrix was inverted; otherwise, false. + BOOL D2D1IsMatrixInvertible([In] const D2D1_MATRIX_3X2_F* matrix) + + + + Attempts to invert the specified matrix. + + The matrix to invert. + BOOLtrue if the matrix was inverted; otherwise, false. + BOOL D2D1InvertMatrix([InOut] D2D1_MATRIX_3X2_F* matrix) + + + + Represents an collection of objects for linear and radial gradient brushes. + + ID2D1GradientStopCollection + + + + Initializes a new instance of the class. + + The native pointer. + + + + Retrieves the number of gradient stops in the collection. + + UINT32The number of gradient stops in the collection. + int ID2D1GradientStopCollection::GetGradientStopCount() + + + + Copies the gradient stops from the collection into an array of structures. + + + Gradient stops are copied in order of position, starting with the gradient stop with the smallest position value and progressing to the gradient stop with the largest position value. + + A reference to a one-dimensional array of structures. When this method returns, the array contains copies of the collection's gradient stops. You must allocate the memory for this array. + A value indicating the number of gradient stops to copy. If the value is less than the number of gradient stops in the collection, the remaining gradient stops are omitted. If the value is larger than the number of gradient stops in the collection, the extra gradient stops are set to NULL. To obtain the number of gradient stops in the collection, use the {{GetGradientStopCount}} method. + void ID2D1GradientStopCollection::GetGradientStops([Out, Buffer] D2D1_GRADIENT_STOP* gradientStops,[None] int gradientStopsCount) + + + + Indicates the gamma space in which the gradient stops are interpolated. + + D2D1_GAMMAThe gamma space in which the gradient stops are interpolated. + D2D1_GAMMA ID2D1GradientStopCollection::GetColorInterpolationGamma() + + + + Indicates the behavior of the gradient outside the normalized gradient range. + + D2D1_EXTEND_MODEThe behavior of the gradient outside the [0,1] normalized gradient range. + D2D1_EXTEND_MODE ID2D1GradientStopCollection::GetExtendMode() + + + + Creates an from the specified gradient stops, a Gamma StandardRgb, and ExtendMode.Clamp. + + an instance of + A pointer to an array of D2D1_GRADIENT_STOP structures. + HRESULT CreateGradientStopCollection([In, Buffer] const D2D1_GRADIENT_STOP* gradientStops,[None] UINT gradientStopsCount,[None] D2D1_GAMMA colorInterpolationGamma,[None] D2D1_EXTEND_MODE extendMode,[Out] ID2D1GradientStopCollection** gradientStopCollection) + + + + Creates an from the specified gradient stops, color Gamma.StandardRgb, and extend mode. + + an instance of + A pointer to an array of D2D1_GRADIENT_STOP structures. + The behavior of the gradient outside the [0,1] normalized range. + HRESULT CreateGradientStopCollection([In, Buffer] const D2D1_GRADIENT_STOP* gradientStops,[None] UINT gradientStopsCount,[None] D2D1_GAMMA colorInterpolationGamma,[None] D2D1_EXTEND_MODE extendMode,[Out] ID2D1GradientStopCollection** gradientStopCollection) + + + + Creates an from the specified gradient stops, color interpolation gamma, and ExtendMode.Clamp. + + an instance of + A pointer to an array of D2D1_GRADIENT_STOP structures. + The space in which color interpolation between the gradient stops is performed. + HRESULT CreateGradientStopCollection([In, Buffer] const D2D1_GRADIENT_STOP* gradientStops,[None] UINT gradientStopsCount,[None] D2D1_GAMMA colorInterpolationGamma,[None] D2D1_EXTEND_MODE extendMode,[Out] ID2D1GradientStopCollection** gradientStopCollection) + + + + Creates an from the specified gradient stops, color interpolation gamma, and extend mode. + + an instance of + A pointer to an array of D2D1_GRADIENT_STOP structures. + The space in which color interpolation between the gradient stops is performed. + The behavior of the gradient outside the [0,1] normalized range. + HRESULT CreateGradientStopCollection([In, Buffer] const D2D1_GRADIENT_STOP* gradientStops,[None] UINT gradientStopsCount,[None] D2D1_GAMMA colorInterpolationGamma,[None] D2D1_EXTEND_MODE extendMode,[Out] ID2D1GradientStopCollection** gradientStopCollection) + + + + Retrieves the number of gradient stops in the collection. + + int ID2D1GradientStopCollection::GetGradientStopCount() + + + + Indicates the gamma space in which the gradient stops are interpolated. + + D2D1_GAMMA ID2D1GradientStopCollection::GetColorInterpolationGamma() + + + + Indicates the behavior of the gradient outside the normalized gradient range. + + D2D1_EXTEND_MODE ID2D1GradientStopCollection::GetExtendMode() + + + + Paints an area with a solid color. + + ID2D1SolidColorBrush + + + + Initializes a new instance of the class. + + The native pointer. + + + + Specifies the color of this solid color brush. + + + To help create colors, Direct2D provides the {{ColorF}} class. It offers several helper methods for creating colors and provides a set or predefined colors. + + The color of this solid color brush. + void ID2D1SolidColorBrush::SetColor([In] const D2D1_COLOR_F* color) + + + + Retrieves the color of the solid color brush. + + The color of this solid color brush. + D2D1_COLOR_F ID2D1SolidColorBrush::GetColor() + + + + Creates a new that has the specified color and opacity. + + an instance of + The red, green, blue, and alpha values of the brush's color. + + + + Creates a new that has the specified color and opacity. + + an instance of + The red, green, blue, and alpha values of the brush's color. + The base opacity of the brush. + + + + Retrieves the color of the solid color brush. + + D2D1_COLOR_F ID2D1SolidColorBrush::GetColor() + + + + Paints an area with a linear gradient. + + ID2D1LinearGradientBrush + + + + Initializes a new instance of the class. + + The native pointer. + + + + Sets the starting coordinates of the linear gradient in the brush's coordinate space. + + + The start point and end point are described in the brush's space and are mapped to the render target when the brush is used. If there is a non-identity brush transform or render target transform, the brush's start point and end point are also transformed. + + The starting two-dimensional coordinates of the linear gradient, in the brush's coordinate space. + void ID2D1LinearGradientBrush::SetStartPoint([None] D2D1_POINT_2F startPoint) + + + + Sets the ending coordinates of the linear gradient in the brush's coordinate space. + + + The start point and end point are described in the brush's space and are mapped to the render target when the brush is used. If there is a non-identity brush transform or render target transform, the brush's start point and end point are also transformed. + + The ending two-dimensional coordinates of the linear gradient, in the brush's coordinate space. + void ID2D1LinearGradientBrush::SetEndPoint([None] D2D1_POINT_2F endPoint) + + + + Retrieves the starting coordinates of the linear gradient. + + + The start point and end point are described in the brush's space and are mapped to the render target when the brush is used. If there is a non-identity brush transform or render target transform, the brush's start point and end point are also transformed. + + The starting two-dimensional coordinates of the linear gradient, in the brush's coordinate space. + D2D1_POINT_2F ID2D1LinearGradientBrush::GetStartPoint() + + + + Retrieves the ending coordinates of the linear gradient. + + + The start point and end point are described in the brush's space and are mapped to the render target when the brush is used. If there is a non-identity brush transform or render target transform, the brush's start point and end point are also transformed. + + The ending two-dimensional coordinates of the linear gradient, in the brush's coordinate space. + D2D1_POINT_2F ID2D1LinearGradientBrush::GetEndPoint() + + + + Retrieves the associated with this linear gradient brush. + + + contains an array of structures and information, such as the extend mode and the color interpolation mode. + + The object associated with this linear gradient brush object. This parameter is passed uninitialized. + void ID2D1LinearGradientBrush::GetGradientStopCollection([Out] ID2D1GradientStopCollection** gradientStopCollection) + + + + Creates an that contains the specified gradient stops and has the specified transform and base opacity. + + an instance of + The start and end points of the gradient. + A collection of structures that describe the colors in the brush's gradient and their locations along the gradient line. + HRESULT CreateLinearGradientBrush([In] const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES* linearGradientBrushProperties,[In, Optional] const D2D1_BRUSH_PROPERTIES* brushProperties,[In] ID2D1GradientStopCollection* gradientStopCollection,[Out] ID2D1LinearGradientBrush** linearGradientBrush) + + + + Creates an that contains the specified gradient stops and has the specified transform and base opacity. + + an instance of + The start and end points of the gradient. + The transform and base opacity of the new brush, or NULL. If this value is NULL, the brush defaults to a base opacity of 1.0f and the identity matrix as its transformation. + A collection of structures that describe the colors in the brush's gradient and their locations along the gradient line. + HRESULT CreateLinearGradientBrush([In] const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES* linearGradientBrushProperties,[In, Optional] const D2D1_BRUSH_PROPERTIES* brushProperties,[In] ID2D1GradientStopCollection* gradientStopCollection,[Out] ID2D1LinearGradientBrush** linearGradientBrush) + + + + Retrieves the starting coordinates of the linear gradient. + + + The start point and end point are described in the brush's space and are mapped to the render target when the brush is used. If there is a non-identity brush transform or render target transform, the brush's start point and end point are also transformed. + + D2D1_POINT_2F ID2D1LinearGradientBrush::GetStartPoint() + + + + Retrieves the ending coordinates of the linear gradient. + + + The start point and end point are described in the brush's space and are mapped to the render target when the brush is used. If there is a non-identity brush transform or render target transform, the brush's start point and end point are also transformed. + + D2D1_POINT_2F ID2D1LinearGradientBrush::GetEndPoint() + + + + Retrieves the associated with this linear gradient brush. + + + contains an array of structures and information, such as the extend mode and the color interpolation mode. + + void ID2D1LinearGradientBrush::GetGradientStopCollection([Out] ID2D1GradientStopCollection** gradientStopCollection) + + + + Paints an area with a radial gradient. + + ID2D1RadialGradientBrush + + + + Initializes a new instance of the class. + + The native pointer. + + + + Specifies the center of the gradient ellipse in the brush's coordinate space. + + The center of the gradient ellipse, in the brush's coordinate space. + void ID2D1RadialGradientBrush::SetCenter([None] D2D1_POINT_2F center) + + + + Specifies the offset of the gradient origin relative to the gradient ellipse's center. + + The offset of the gradient origin from the center of the gradient ellipse. + void ID2D1RadialGradientBrush::SetGradientOriginOffset([None] D2D1_POINT_2F gradientOriginOffset) + + + + Specifies the x-radius of the gradient ellipse, in the brush's coordinate space. + + The x-radius of the gradient ellipse. This value is in the brush's coordinate space. + void ID2D1RadialGradientBrush::SetRadiusX([None] float radiusX) + + + + Specifies the y-radius of the gradient ellipse, in the brush's coordinate space. + + The y-radius of the gradient ellipse. This value is in the brush's coordinate space. + void ID2D1RadialGradientBrush::SetRadiusY([None] float radiusY) + + + + Retrieves the center of the gradient ellipse. + + The center of the gradient ellipse. This value is expressed in the brush's coordinate space. + D2D1_POINT_2F ID2D1RadialGradientBrush::GetCenter() + + + + Retrieves the offset of the gradient origin relative to the gradient ellipse's center. + + The offset of the gradient origin from the center of the gradient ellipse. This value is expressed in the brush's coordinate space. + D2D1_POINT_2F ID2D1RadialGradientBrush::GetGradientOriginOffset() + + + + Retrieves the x-radius of the gradient ellipse. + + FLOATThe x-radius of the gradient ellipse. This value is expressed in the brush's coordinate space. + float ID2D1RadialGradientBrush::GetRadiusX() + + + + Retrieves the y-radius of the gradient ellipse. + + FLOATThe y-radius of the gradient ellipse. This value is expressed in the brush's coordinate space. + float ID2D1RadialGradientBrush::GetRadiusY() + + + + Retrieves the associated with this radial gradient brush object. + + + contains an array of structures and additional information, such as the extend mode and the color interpolation mode. + + The object associated with this linear gradient brush object. This parameter is passed uninitialized. + void ID2D1RadialGradientBrush::GetGradientStopCollection([Out] ID2D1GradientStopCollection** gradientStopCollection) + + + + Creates an that contains the specified gradient stops and has the specified transform and base opacity. + + an instance of + The center, gradient origin offset, and x-radius and y-radius of the brush's gradient. + A collection of structures that describe the colors in the brush's gradient and their locations along the gradient. + HRESULT CreateRadialGradientBrush([In] const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES* radialGradientBrushProperties,[In, Optional] const D2D1_BRUSH_PROPERTIES* brushProperties,[In] ID2D1GradientStopCollection* gradientStopCollection,[Out] ID2D1RadialGradientBrush** radialGradientBrush) + + + + Creates an that contains the specified gradient stops and has the specified transform and base opacity. + + an instance of + The center, gradient origin offset, and x-radius and y-radius of the brush's gradient. + A collection of structures that describe the colors in the brush's gradient and their locations along the gradient. + HRESULT CreateRadialGradientBrush([In] const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES* radialGradientBrushProperties,[In, Optional] const D2D1_BRUSH_PROPERTIES* brushProperties,[In] ID2D1GradientStopCollection* gradientStopCollection,[Out] ID2D1RadialGradientBrush** radialGradientBrush) + + + + Creates an that contains the specified gradient stops and has the specified transform and base opacity. + + an instance of + The center, gradient origin offset, and x-radius and y-radius of the brush's gradient. + The transform and base opacity of the new brush, or NULL. If this value is NULL, the brush defaults to a base opacity of 1.0f and the identity matrix as its transformation. + A collection of structures that describe the colors in the brush's gradient and their locations along the gradient. + HRESULT CreateRadialGradientBrush([In] const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES* radialGradientBrushProperties,[In, Optional] const D2D1_BRUSH_PROPERTIES* brushProperties,[In] ID2D1GradientStopCollection* gradientStopCollection,[Out] ID2D1RadialGradientBrush** radialGradientBrush) + + + + Creates an that contains the specified gradient stops and has the specified transform and base opacity. + + an instance of + The center, gradient origin offset, and x-radius and y-radius of the brush's gradient. + The transform and base opacity of the new brush, or NULL. If this value is NULL, the brush defaults to a base opacity of 1.0f and the identity matrix as its transformation. + A collection of structures that describe the colors in the brush's gradient and their locations along the gradient. + HRESULT CreateRadialGradientBrush([In] const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES* radialGradientBrushProperties,[In, Optional] const D2D1_BRUSH_PROPERTIES* brushProperties,[In] ID2D1GradientStopCollection* gradientStopCollection,[Out] ID2D1RadialGradientBrush** radialGradientBrush) + + + + Retrieves the center of the gradient ellipse. + + D2D1_POINT_2F ID2D1RadialGradientBrush::GetCenter() + + + + Retrieves the offset of the gradient origin relative to the gradient ellipse's center. + + D2D1_POINT_2F ID2D1RadialGradientBrush::GetGradientOriginOffset() + + + + Retrieves the x-radius of the gradient ellipse. + + float ID2D1RadialGradientBrush::GetRadiusX() + + + + Retrieves the y-radius of the gradient ellipse. + + float ID2D1RadialGradientBrush::GetRadiusY() + + + + Retrieves the associated with this radial gradient brush object. + + + contains an array of structures and additional information, such as the extend mode and the color interpolation mode. + + void ID2D1RadialGradientBrush::GetGradientStopCollection([Out] ID2D1GradientStopCollection** gradientStopCollection) + + + + Describes the caps, miter limit, line join, and dash information for a stroke. + + ID2D1StrokeStyle + + + + Initializes a new instance of the class. + + The native pointer. + + + + Retrieves the type of shape used at the beginning of a stroke. + + The type of shape used at the beginning of a stroke. + D2D1_CAP_STYLE ID2D1StrokeStyle::GetStartCap() + + + + Retrieves the type of shape used at the end of a stroke. + + The type of shape used at the end of a stroke. + D2D1_CAP_STYLE ID2D1StrokeStyle::GetEndCap() + + + + Gets a value that specifies how the ends of each dash are drawn. + + A value that specifies how the ends of each dash are drawn. + D2D1_CAP_STYLE ID2D1StrokeStyle::GetDashCap() + + + + Retrieves the limit on the ratio of the miter length to half the stroke's thickness. + + FLOATA positive number greater than or equal to 1.0f that describes the limit on the ratio of the miter length to half the stroke's thickness. + float ID2D1StrokeStyle::GetMiterLimit() + + + + Retrieves the type of joint used at the vertices of a shape's outline. + + A value that specifies the type of joint used at the vertices of a shape's outline. + D2D1_LINE_JOIN ID2D1StrokeStyle::GetLineJoin() + + + + Retrieves a value that specifies how far in the dash sequence the stroke will start. + + FLOATA value that specifies how far in the dash sequence the stroke will start. + float ID2D1StrokeStyle::GetDashOffset() + + + + Gets a value that describes the stroke's dash pattern. + + + If a custom dash style is specified, the dash pattern is described by the dashes array, which can be retrieved by calling the {{GetDashes}} method. + + A value that describes the predefined dash pattern used, or if a custom dash style is used. + D2D1_DASH_STYLE ID2D1StrokeStyle::GetDashStyle() + + + + Retrieves the number of entries in the dashes array. + + UINT32The number of entries in the dashes array if the stroke is dashed; otherwise, 0. + int ID2D1StrokeStyle::GetDashesCount() + + + + Copies the dash pattern to the specified array. + + + The dashes are specified in units that are a multiple of the stroke width, with subsequent members of the array indicating the dashes and gaps between dashes: the first entry indicates a filled dash, the second a gap, and so on. + + A reference to an array that will receive the dash pattern. The array must be able to contain at least as many elements as specified by dashesCount. You must allocate storage for this array. + The number of dashes to copy. If this value is less than the number of dashes in the stroke style's dashes array, the returned dashes are truncated to dashesCount. If this value is greater than the number of dashes in the stroke style's dashes array, the extra dashes are set to 0.0f. To obtain the actual number of dashes in the stroke style's dashes array, use the {{GetDashesCount}} method. + void ID2D1StrokeStyle::GetDashes([Out, Buffer] float* dashes,[None] int dashesCount) + + + + Creates an that describes start cap, dash pattern, and other features of a stroke. + + an instance of + a definition for this render target + + + + Creates an that describes start cap, dash pattern, and other features of a stroke. + + an instance of + A structure that describes the stroke's line cap, dash offset, and other details of a stroke. + An array whose elements are set to the length of each dash and space in the dash pattern. The first element sets the length of a dash, the second element sets the length of a space, the third element sets the length of a dash, and so on. The length of each dash and space in the dash pattern is the product of the element value in the array and the stroke width. + + + + Retrieves the type of shape used at the beginning of a stroke. + + D2D1_CAP_STYLE ID2D1StrokeStyle::GetStartCap() + + + + Retrieves the type of shape used at the end of a stroke. + + D2D1_CAP_STYLE ID2D1StrokeStyle::GetEndCap() + + + + Gets a value that specifies how the ends of each dash are drawn. + + D2D1_CAP_STYLE ID2D1StrokeStyle::GetDashCap() + + + + Retrieves the limit on the ratio of the miter length to half the stroke's thickness. + + float ID2D1StrokeStyle::GetMiterLimit() + + + + Retrieves the type of joint used at the vertices of a shape's outline. + + D2D1_LINE_JOIN ID2D1StrokeStyle::GetLineJoin() + + + + Retrieves a value that specifies how far in the dash sequence the stroke will start. + + float ID2D1StrokeStyle::GetDashOffset() + + + + Gets a value that describes the stroke's dash pattern. + + + If a custom dash style is specified, the dash pattern is described by the dashes array, which can be retrieved by calling the {{GetDashes}} method. + + D2D1_DASH_STYLE ID2D1StrokeStyle::GetDashStyle() + + + + Retrieves the number of entries in the dashes array. + + int ID2D1StrokeStyle::GetDashesCount() + + + + Represents a geometry resource and defines a set of helper methods for manipulating and measuring geometric shapes. Interfaces that inherit from ID2D1Geometry define specific shapes. + + ID2D1Geometry + + + + Default flattening tolerance used for all methods that are not explicitly using it. Default is set to 0.25f. + + + + + Initializes a new instance of the class. + + The native pointer. + + + + Retrieves the bounds of the geometry. + + The transform to apply to this geometry before calculating its bounds, or NULL. + When this method returns, contains the bounds of this geometry. If the bounds are empty, this will be a rect where bounds.left > bounds.right. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::GetBounds([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[Out] D2D1_RECT_F* bounds) + + + + Gets the bounds of the geometry after it has been widened by the specified stroke width and style and transformed by the specified matrix. + + The amount by which to widen the geometry by stroking its outline. + The style of the stroke that widens the geometry. + A transform to apply to the geometry after the geometry is transformed and after the geometry has been stroked, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + When this method returns, contains the bounds of the widened geometry. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::GetWidenedBounds([None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] D2D1_RECT_F* bounds) + + + + Determines whether the geometry's stroke contains the specified point given the specified stroke thickness, style, and transform. + + The point to test for containment. + The thickness of the stroke to apply. + The style of stroke to apply. + The transform to apply to the stroked geometry. + The numeric accuracy with which the precise geometric path and path intersection is calculated. Points missing the stroke by less than the tolerance are still considered inside. Smaller values produce more accurate results but cause slower execution. + When this method returns, contains a boolean value set to true if the geometry's stroke contains the specified point; otherwise, false. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::StrokeContainsPoint([None] D2D1_POINT_2F point,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] BOOL* contains) + + + + Indicates whether the area filled by the geometry would contain the specified point given the specified flattening tolerance. + + The point to test. + The transform to apply to the geometry prior to testing for containment, or NULL. + The numeric accuracy with which the precise geometric path and path intersection is calculated. Points missing the fill by less than the tolerance are still considered inside. Smaller values produce more accurate results but cause slower execution. + When this method returns, contains a bool value that is true if the area filled by the geometry contains point; otherwise, false.You must allocate storage for this parameter. + HRESULT ID2D1Geometry::FillContainsPoint([None] D2D1_POINT_2F point,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] BOOL* contains) + + + + Describes the intersection between this geometry and the specified geometry. The comparison is performed by using the specified flattening tolerance. + + + When interpreting the returned relation value, it is important to remember that the member of the D2D1_GEOMETRY_RELATION enumeration type means that this geometry is contained inside inputGeometry, not that this geometry contains inputGeometry. For more information about how to interpret other possible return values, see . + + The geometry to test. + The transform to apply to inputGeometry, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometries. Smaller values produce more accurate results but cause slower execution. + When this method returns, contains a reference to a value that describes how this geometry is related to inputGeometry. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::CompareWithGeometry([In] ID2D1Geometry* inputGeometry,[In, Optional] const D2D1_MATRIX_3X2_F* inputGeometryTransform,[None] float flatteningTolerance,[Out] D2D1_GEOMETRY_RELATION* relation) + + + + Creates a simplified version of the geometry that contains only lines and (optionally) cubic Bezier curves and writes the result to an . + + A value that specifies whether the simplified geometry should contain curves. + The transform to apply to the simplified geometry, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + The to which the simplified geometry is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Geometry::Simplify([None] D2D1_GEOMETRY_SIMPLIFICATION_OPTION simplificationOption,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Creates a set of clockwise-wound triangles that cover the geometry after it has been transformed using the specified matrix and flattened using the specified tolerance. + + The transform to apply to this geometry, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + The to which the tessellated is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Geometry::Tessellate([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[In] ID2D1TessellationSink* tessellationSink) + + + + Combines this geometry with the specified geometry and stores the result in an . + + The geometry to combine with this instance. + The type of combine operation to perform. + The transform to apply to inputGeometry before combining, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometries. Smaller values produce more accurate results but cause slower execution. + The result of the combine operation. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Geometry::CombineWithGeometry([In] ID2D1Geometry* inputGeometry,[None] D2D1_COMBINE_MODE combineMode,[In, Optional] const D2D1_MATRIX_3X2_F* inputGeometryTransform,[None] float flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Computes the outline of the geometry and writes the result to an . + + + The {{Outline}} method allows the caller to produce a geometry with an equivalent fill to the input geometry, with the following additional properties: The output geometry contains no transverse intersections; that is, segments may touch, but they never cross. The outermost figures in the output geometry are all oriented counterclockwise. The output geometry is fill-mode invariant; that is, the fill of the geometry does not depend on the choice of the fill mode. For more information about the fill mode, see . Additionally, the {{Outline}} method can be useful in removing redundant portions of said geometries to simplify complex geometries. It can also be useful in combination with to create unions among several geometries simultaneously. + + + The transform to apply to the geometry outline, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + The to which the geometry's transformed outline is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Geometry::Outline([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Computes the area of the geometry after it has been transformed by the specified matrix and flattened using the specified tolerance. + + The transform to apply to this geometry before computing its area, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + When this this method returns, contains a reference to the area of the transformed, flattened version of this geometry. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::ComputeArea([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] float* area) + + + + Calculates the length of the geometry as though each segment were unrolled into a line. + + The transform to apply to the geometry before calculating its length, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + When this method returns, contains a reference to the length of the geometry. For closed geometries, the length includes an implicit closing segment. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::ComputeLength([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] float* length) + + + + Calculates the point and tangent vector at the specified distance along the geometry after it has been transformed by the specified matrix and flattened using the specified tolerance. + + The distance along the geometry of the point and tangent to find. If this distance is less then 0, this method calculates the first point in the geometry. If this distance is greater than the length of the geometry, this method calculates the last point in the geometry. + The transform to apply to the geometry before calculating the specified point and tangent, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + Whenthis method returns, contains a reference to the tangent vector at the specified distance along the geometry. If the geometry is empty, this vector contains NaN as its x and y values. You must allocate storage for this parameter. + The location at the specified distance along the geometry. If the geometry is empty, this point contains NaN as its x and y values. + HRESULT ID2D1Geometry::ComputePointAtLength([None] float length,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out, Optional] D2D1_POINT_2F* point,[Out, Optional] D2D1_POINT_2F* unitTangentVector) + + + + Widens the geometry by the specified stroke and writes the result to an after it has been transformed by the specified matrix and flattened using the specified tolerance. + + The amount by which to widen the geometry. + The style of stroke to apply to the geometry, or NULL. + The transform to apply to the geometry after widening it, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + The to which the widened geometry is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Geometry::Widen([None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Combines this geometry with the specified geometry and stores the result in an . + + The geometry to combine with this instance. + The type of combine operation to perform. + The result of the combine operation. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT CombineWithGeometry([In] ID2D1Geometry* inputGeometry,[None] D2D1_COMBINE_MODE combineMode,[In, Optional] const D2D1_MATRIX_3X2_F* inputGeometryTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Combines this geometry with the specified geometry and stores the result in an . + + The geometry to combine with this instance. + The type of combine operation to perform. + The maximum bounds on the distance between points in the polygonal approximation of the geometries. Smaller values produce more accurate results but cause slower execution. + The result of the combine operation. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT CombineWithGeometry([In] ID2D1Geometry* inputGeometry,[None] D2D1_COMBINE_MODE combineMode,[In, Optional] const D2D1_MATRIX_3X2_F* inputGeometryTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Combines this geometry with the specified geometry and stores the result in an . + + The geometry to combine with this instance. + The type of combine operation to perform. + The transform to apply to inputGeometry before combining, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometries. Smaller values produce more accurate results but cause slower execution. + The result of the combine operation. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT CombineWithGeometry([In] ID2D1Geometry* inputGeometry,[None] D2D1_COMBINE_MODE combineMode,[In, Optional] const D2D1_MATRIX_3X2_F* inputGeometryTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Describes the intersection between this geometry and the specified geometry. The comparison is performed by using the specified flattening tolerance. + + + When interpreting the returned relation value, it is important to remember that the member of the D2D1_GEOMETRY_RELATION enumeration type means that this geometry is contained inside inputGeometry, not that this geometry contains inputGeometry. For more information about how to interpret other possible return values, see . + + The geometry to test. + When this method returns, contains a reference to a value that describes how this geometry is related to inputGeometry. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::CompareWithGeometry([In] ID2D1Geometry* inputGeometry,[In, Optional] const D2D1_MATRIX_3X2_F* inputGeometryTransform,[None] float flatteningTolerance,[Out] D2D1_GEOMETRY_RELATION* relation) + + + + Describes the intersection between this geometry and the specified geometry. The comparison is performed by using the specified flattening tolerance. + + + When interpreting the returned relation value, it is important to remember that the member of the D2D1_GEOMETRY_RELATION enumeration type means that this geometry is contained inside inputGeometry, not that this geometry contains inputGeometry. For more information about how to interpret other possible return values, see . + + The geometry to test. + The maximum bounds on the distance between points in the polygonal approximation of the geometries. Smaller values produce more accurate results but cause slower execution. + When this method returns, contains a reference to a value that describes how this geometry is related to inputGeometry. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::CompareWithGeometry([In] ID2D1Geometry* inputGeometry,[In, Optional] const D2D1_MATRIX_3X2_F* inputGeometryTransform,[None] float flatteningTolerance,[Out] D2D1_GEOMETRY_RELATION* relation) + + + + Computes the area of the geometry after it has been transformed by the specified matrix and flattened using the specified tolerance. + + When this this method returns, contains a reference to the area of the transformed, flattened version of this geometry. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::ComputeArea([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] float* area) + + + + Computes the area of the geometry after it has been transformed by the specified matrix and flattened using the specified tolerance. + + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + When this this method returns, contains a reference to the area of the transformed, flattened version of this geometry. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::ComputeArea([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] float* area) + + + + Calculates the length of the geometry as though each segment were unrolled into a line. + + When this method returns, contains a reference to the length of the geometry. For closed geometries, the length includes an implicit closing segment. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::ComputeLength([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] float* length) + + + + Calculates the length of the geometry as though each segment were unrolled into a line. + + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + When this method returns, contains a reference to the length of the geometry. For closed geometries, the length includes an implicit closing segment. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::ComputeLength([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] float* length) + + + + Calculates the point and tangent vector at the specified distance along the geometry after it has been transformed by the specified matrix and flattened using the specified tolerance. + + The distance along the geometry of the point and tangent to find. If this distance is less then 0, this method calculates the first point in the geometry. If this distance is greater than the length of the geometry, this method calculates the last point in the geometry. + Whenthis method returns, contains a reference to the tangent vector at the specified distance along the geometry. If the geometry is empty, this vector contains NaN as its x and y values. You must allocate storage for this parameter. + The location at the specified distance along the geometry. If the geometry is empty, this point contains NaN as its x and y values. + HRESULT ID2D1Geometry::ComputePointAtLength([None] float length,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out, Optional] D2D1_POINT_2F* point,[Out, Optional] D2D1_POINT_2F* unitTangentVector) + + + + Calculates the point and tangent vector at the specified distance along the geometry after it has been transformed by the specified matrix and flattened using the specified tolerance. + + The distance along the geometry of the point and tangent to find. If this distance is less then 0, this method calculates the first point in the geometry. If this distance is greater than the length of the geometry, this method calculates the last point in the geometry. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + Whenthis method returns, contains a reference to the tangent vector at the specified distance along the geometry. If the geometry is empty, this vector contains NaN as its x and y values. You must allocate storage for this parameter. + The location at the specified distance along the geometry. If the geometry is empty, this point contains NaN as its x and y values. + HRESULT ID2D1Geometry::ComputePointAtLength([None] float length,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out, Optional] D2D1_POINT_2F* point,[Out, Optional] D2D1_POINT_2F* unitTangentVector) + + + + Indicates whether the area filled by the geometry would contain the specified point given the specified flattening tolerance. + + The point to test. + When this method returns, contains a bool value that is true if the area filled by the geometry contains point; otherwise, false.You must allocate storage for this parameter. + HRESULT ID2D1Geometry::FillContainsPoint([None] D2D1_POINT_2F point,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] BOOL* contains) + + + + Indicates whether the area filled by the geometry would contain the specified point given the specified flattening tolerance. + + The point to test. + When this method returns, contains a bool value that is true if the area filled by the geometry contains point; otherwise, false.You must allocate storage for this parameter. + HRESULT ID2D1Geometry::FillContainsPoint([None] D2D1_POINT_2F point,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] BOOL* contains) + + + + Indicates whether the area filled by the geometry would contain the specified point given the specified flattening tolerance. + + The point to test. + The numeric accuracy with which the precise geometric path and path intersection is calculated. Points missing the fill by less than the tolerance are still considered inside. Smaller values produce more accurate results but cause slower execution. + When this method returns, contains a bool value that is true if the area filled by the geometry contains point; otherwise, false.You must allocate storage for this parameter. + HRESULT ID2D1Geometry::FillContainsPoint([None] D2D1_POINT_2F point,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] BOOL* contains) + + + + Indicates whether the area filled by the geometry would contain the specified point given the specified flattening tolerance. + + The point to test. + The numeric accuracy with which the precise geometric path and path intersection is calculated. Points missing the fill by less than the tolerance are still considered inside. Smaller values produce more accurate results but cause slower execution. + When this method returns, contains a bool value that is true if the area filled by the geometry contains point; otherwise, false.You must allocate storage for this parameter. + HRESULT ID2D1Geometry::FillContainsPoint([None] D2D1_POINT_2F point,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] BOOL* contains) + + + + Indicates whether the area filled by the geometry would contain the specified point given the specified flattening tolerance. + + The point to test. + The transform to apply to the geometry prior to testing for containment, or NULL. + The numeric accuracy with which the precise geometric path and path intersection is calculated. Points missing the fill by less than the tolerance are still considered inside. Smaller values produce more accurate results but cause slower execution. + When this method returns, contains a bool value that is true if the area filled by the geometry contains point; otherwise, false.You must allocate storage for this parameter. + HRESULT ID2D1Geometry::FillContainsPoint([None] D2D1_POINT_2F point,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] BOOL* contains) + + + + Retrieves the bounds of the geometry. + + When this method returns, contains the bounds of this geometry. If the bounds are empty, this will be a rect where bounds.left > bounds.right. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::GetBounds([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[Out] D2D1_RECT_F* bounds) + + + + Gets the bounds of the geometry after it has been widened by the specified stroke width and style and transformed by the specified matrix. + + The amount by which to widen the geometry by stroking its outline. + When this method returns, contains the bounds of the widened geometry. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::GetWidenedBounds([None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] D2D1_RECT_F* bounds) + + + + Gets the bounds of the geometry after it has been widened by the specified stroke width and style and transformed by the specified matrix. + + The amount by which to widen the geometry by stroking its outline. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + When this method returns, contains the bounds of the widened geometry. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::GetWidenedBounds([None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] D2D1_RECT_F* bounds) + + + + Gets the bounds of the geometry after it has been widened by the specified stroke width and style and transformed by the specified matrix. + + The amount by which to widen the geometry by stroking its outline. + The style of the stroke that widens the geometry. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + When this method returns, contains the bounds of the widened geometry. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::GetWidenedBounds([None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] D2D1_RECT_F* bounds) + + + + Computes the outline of the geometry and writes the result to an . + + + The {{Outline}} method allows the caller to produce a geometry with an equivalent fill to the input geometry, with the following additional properties: The output geometry contains no transverse intersections; that is, segments may touch, but they never cross.The outermost figures in the output geometry are all oriented counterclockwise. The output geometry is fill-mode invariant; that is, the fill of the geometry does not depend on the choice of the fill mode. For more information about the fill mode, see .Additionally, the {{Outline}} method can be useful in removing redundant portions of said geometries to simplify complex geometries. It can also be useful in combination with to create unions among several geometries simultaneously. + + The to which the geometry's transformed outline is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Outline([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Computes the outline of the geometry and writes the result to an . + + + The {{Outline}} method allows the caller to produce a geometry with an equivalent fill to the input geometry, with the following additional properties: The output geometry contains no transverse intersections; that is, segments may touch, but they never cross.The outermost figures in the output geometry are all oriented counterclockwise. The output geometry is fill-mode invariant; that is, the fill of the geometry does not depend on the choice of the fill mode. For more information about the fill mode, see .Additionally, the {{Outline}} method can be useful in removing redundant portions of said geometries to simplify complex geometries. It can also be useful in combination with to create unions among several geometries simultaneously. + + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + The to which the geometry's transformed outline is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Outline([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Computes the outline of the geometry and writes the result to an . + + + The {{Outline}} method allows the caller to produce a geometry with an equivalent fill to the input geometry, with the following additional properties: The output geometry contains no transverse intersections; that is, segments may touch, but they never cross.The outermost figures in the output geometry are all oriented counterclockwise. The output geometry is fill-mode invariant; that is, the fill of the geometry does not depend on the choice of the fill mode. For more information about the fill mode, see .Additionally, the {{Outline}} method can be useful in removing redundant portions of said geometries to simplify complex geometries. It can also be useful in combination with to create unions among several geometries simultaneously. + + The transform to apply to the geometry outline, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + The to which the geometry's transformed outline is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Outline([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Creates a simplified version of the geometry that contains only lines and (optionally) cubic Bezier curves and writes the result to an . + + A value that specifies whether the simplified geometry should contain curves. + The to which the simplified geometry is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Simplify([None] D2D1_GEOMETRY_SIMPLIFICATION_OPTION simplificationOption,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Creates a simplified version of the geometry that contains only lines and (optionally) cubic Bezier curves and writes the result to an . + + A value that specifies whether the simplified geometry should contain curves. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + The to which the simplified geometry is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Simplify([None] D2D1_GEOMETRY_SIMPLIFICATION_OPTION simplificationOption,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Creates a simplified version of the geometry that contains only lines and (optionally) cubic Bezier curves and writes the result to an . + + A value that specifies whether the simplified geometry should contain curves. + The transform to apply to the simplified geometry, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + The to which the simplified geometry is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Simplify([None] D2D1_GEOMETRY_SIMPLIFICATION_OPTION simplificationOption,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Determines whether the geometry's stroke contains the specified point given the specified stroke thickness, style, and transform. + + The point to test for containment. + The thickness of the stroke to apply. + When this method returns, contains a boolean value set to true if the geometry's stroke contains the specified point; otherwise, false. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::StrokeContainsPoint([None] D2D1_POINT_2F point,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] BOOL* contains) + + + + Determines whether the geometry's stroke contains the specified point given the specified stroke thickness, style, and transform. + + The point to test for containment. + The thickness of the stroke to apply. + When this method returns, contains a boolean value set to true if the geometry's stroke contains the specified point; otherwise, false. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::StrokeContainsPoint([None] D2D1_POINT_2F point,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] BOOL* contains) + + + + Determines whether the geometry's stroke contains the specified point given the specified stroke thickness, style, and transform. + + The point to test for containment. + The thickness of the stroke to apply. + The style of stroke to apply. + When this method returns, contains a boolean value set to true if the geometry's stroke contains the specified point; otherwise, false. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::StrokeContainsPoint([None] D2D1_POINT_2F point,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] BOOL* contains) + + + + Determines whether the geometry's stroke contains the specified point given the specified stroke thickness, style, and transform. + + The point to test for containment. + The thickness of the stroke to apply. + The style of stroke to apply. + When this method returns, contains a boolean value set to true if the geometry's stroke contains the specified point; otherwise, false. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::StrokeContainsPoint([None] D2D1_POINT_2F point,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] BOOL* contains) + + + + Determines whether the geometry's stroke contains the specified point given the specified stroke thickness, style, and transform. + + The point to test for containment. + The thickness of the stroke to apply. + The style of stroke to apply. + The transform to apply to the stroked geometry. + When this method returns, contains a boolean value set to true if the geometry's stroke contains the specified point; otherwise, false. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::StrokeContainsPoint([None] D2D1_POINT_2F point,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] BOOL* contains) + + + + Determines whether the geometry's stroke contains the specified point given the specified stroke thickness, style, and transform. + + The point to test for containment. + The thickness of the stroke to apply. + The style of stroke to apply. + The transform to apply to the stroked geometry. + When this method returns, contains a boolean value set to true if the geometry's stroke contains the specified point; otherwise, false. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::StrokeContainsPoint([None] D2D1_POINT_2F point,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] BOOL* contains) + + + + Determines whether the geometry's stroke contains the specified point given the specified stroke thickness, style, and transform. + + The point to test for containment. + The thickness of the stroke to apply. + The style of stroke to apply. + The transform to apply to the stroked geometry. + The numeric accuracy with which the precise geometric path and path intersection is calculated. Points missing the stroke by less than the tolerance are still considered inside. Smaller values produce more accurate results but cause slower execution. + When this method returns, contains a boolean value set to true if the geometry's stroke contains the specified point; otherwise, false. You must allocate storage for this parameter. + HRESULT ID2D1Geometry::StrokeContainsPoint([None] D2D1_POINT_2F point,[None] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] float flatteningTolerance,[Out] BOOL* contains) + + + + Creates a set of clockwise-wound triangles that cover the geometry after it has been transformed using the specified matrix and flattened using the specified tolerance + + The to which the tessellated is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Tessellate([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1TessellationSink* tessellationSink) + + + + Creates a set of clockwise-wound triangles that cover the geometry after it has been transformed using the specified matrix and flattened using the specified tolerance + + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + The to which the tessellated is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Tessellate([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1TessellationSink* tessellationSink) + + + + Creates a set of clockwise-wound triangles that cover the geometry after it has been transformed using the specified matrix and flattened using the specified tolerance + + The transform to apply to this geometry, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + The to which the tessellated is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Tessellate([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1TessellationSink* tessellationSink) + + + + Widens the geometry by the specified stroke and writes the result to an after it has been transformed by the specified matrix and flattened using the specified tolerance. + + The amount by which to widen the geometry. + The to which the widened geometry is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Widen([None] FLOAT strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Widens the geometry by the specified stroke and writes the result to an after it has been transformed by the specified matrix and flattened using the specified tolerance. + + The amount by which to widen the geometry. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + The to which the widened geometry is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Widen([None] FLOAT strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Widens the geometry by the specified stroke and writes the result to an after it has been transformed by the specified matrix and flattened using the specified tolerance. + + The amount by which to widen the geometry. + The style of stroke to apply to the geometry, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + The to which the widened geometry is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Widen([None] FLOAT strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Widens the geometry by the specified stroke and writes the result to an after it has been transformed by the specified matrix and flattened using the specified tolerance. + + The amount by which to widen the geometry. + The style of stroke to apply to the geometry, or NULL. + The transform to apply to the geometry after widening it, or NULL. + The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. + The to which the widened geometry is appended. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Widen([None] FLOAT strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink) + + + + Get or set the default flattening tolerance used for all methods that are not explicitly using it. Default is set to 0.25f. + + + + + Describes a two-dimensional rectangle. + + ID2D1RectangleGeometry + + + + Initializes a new instance of the class. + + The native pointer. + + + + Retrieves the rectangle that describes the rectangle geometry's dimensions. + + Contains a reference to a rectangle that describes the rectangle geometry's dimensions when this method returns. You must allocate storage for this parameter. + void ID2D1RectangleGeometry::GetRect([Out] D2D1_RECT_F* rect) + + + + Creates an . + + an instance of + The coordinates of the rectangle geometry. + + + + Retrieves the rectangle that describes the rectangle geometry's dimensions. + + void ID2D1RectangleGeometry::GetRect([Out] D2D1_RECT_F* rect) + + + + Describes a rounded rectangle. + + ID2D1RoundedRectangleGeometry + + + + Initializes a new instance of the class. + + The native pointer. + + + + Retrieves a rounded rectangle that describes this rounded rectangle geometry. + + A reference that receives a rounded rectangle that describes this rounded rectangle geometry. You must allocate storage for this parameter. + void ID2D1RoundedRectangleGeometry::GetRoundedRect([Out] D2D1_ROUNDED_RECT* roundedRect) + + + + Creates an . + + an instance of + The coordinates and corner radii of the rounded rectangle geometry. + + + + Retrieves a rounded rectangle that describes this rounded rectangle geometry. + + void ID2D1RoundedRectangleGeometry::GetRoundedRect([Out] D2D1_ROUNDED_RECT* roundedRect) + + + + Represents an ellipse. + + ID2D1EllipseGeometry + + + + Initializes a new instance of the class. + + The native pointer. + + + + Gets the structure that describes this ellipse geometry. + + When this method returns, contains the that describes the size and position of the ellipse. You must allocate storage for this parameter. + void ID2D1EllipseGeometry::GetEllipse([Out] D2D1_ELLIPSE* ellipse) + + + + Creates an . + + an instance of + A value that describes the center point, x-radius, and y-radius of the ellipse geometry. + + + + Gets the structure that describes this ellipse geometry. + + void ID2D1EllipseGeometry::GetEllipse([Out] D2D1_ELLIPSE* ellipse) + + + + Represents a composite geometry, composed of other objects. + + ID2D1GeometryGroup + + + + Initializes a new instance of the class. + + The native pointer. + + + + Indicates how the intersecting areas of the geometries contained in this geometry group are combined. + + A value that indicates how the intersecting areas of the geometries contained in this geometry group are combined. + D2D1_FILL_MODE ID2D1GeometryGroup::GetFillMode() + + + + Indicates the number of geometry objects in the geometry group. + + UINT32The number of geometries in the . + int ID2D1GeometryGroup::GetSourceGeometryCount() + + + + Retrieves the geometries in the geometry group. + + + The returned geometries are referenced and counted, and the caller must release them. + + When this method returns, contains the address of a reference to an array of geometries to be filled by this method. The length of the array is specified by the geometryCount parameter. If the array is NULL, then this method performs no operation. You must allocate the memory for this array. + A value indicating the number of geometries to return in the geometries array. If this value is less than the number of geometries in the geometry group, the remaining geometries are omitted. If this value is larger than the number of geometries in the geometry group, the extra geometries are set to NULL. To obtain the number of geometries currently in the geometry group, use the {{GetSourceGeometryCount}} method. + void ID2D1GeometryGroup::GetSourceGeometries([Out, Buffer] ID2D1Geometry** geometries,[None] int geometriesCount) + + + + Creates an , which is an object that holds other geometries. + + + Geometry groups are a convenient way to group several geometries simultaneously so all figures of several distinct geometries are concatenated into one. To create a object, call the CreateGeometryGroup method on the object, passing in the fillMode with possible values of (alternate) and D2D1_FILL_MODE_WINDING, an array of geometry objects to add to the geometry group, and the number of elements in this array. + + an instance of + A value that specifies the rule that a composite shape uses to determine whether a given point is part of the geometry. + An array containing the geometry objects to add to the geometry group. The number of elements in this array is indicated by the geometriesCount parameter. + + + + Retrieves the geometries in the geometry group. + + + The returned geometries are referenced and counted, and the caller must release them. + + an array of geometries to be filled by this method. The length of the array is specified by the geometryCount parameter. + void ID2D1GeometryGroup::GetSourceGeometries([Out, Buffer] ID2D1Geometry** geometries,[None] int geometriesCount) + + + + Retrieves the geometries in the geometry group. + + + The returned geometries are referenced and counted, and the caller must release them. + + A value indicating the number of geometries to return in the geometries array. If this value is less than the number of geometries in the geometry group, the remaining geometries are omitted. If this value is larger than the number of geometries in the geometry group, the extra geometries are set to NULL. To obtain the number of geometries currently in the geometry group, use the {{GetSourceGeometryCount}} method. + an array of geometries to be filled by this method. The length of the array is specified by the geometryCount parameter. + void ID2D1GeometryGroup::GetSourceGeometries([Out, Buffer] ID2D1Geometry** geometries,[None] int geometriesCount) + + + + Indicates how the intersecting areas of the geometries contained in this geometry group are combined. + + D2D1_FILL_MODE ID2D1GeometryGroup::GetFillMode() + + + + Indicates the number of geometry objects in the geometry group. + + int ID2D1GeometryGroup::GetSourceGeometryCount() + + + + Represents a geometry that has been transformed. + + ID2D1TransformedGeometry + + + + Initializes a new instance of the class. + + The native pointer. + + + + Retrieves the source geometry of this transformed geometry object. + + When this method returns, contains a reference to a reference to the source geometry for this transformed geometry object. This parameter is passed uninitialized. + void ID2D1TransformedGeometry::GetSourceGeometry([Out] ID2D1Geometry** sourceGeometry) + + + + Retrieves the matrix used to transform the object's source geometry. + + A reference that receives the matrix used to transform the object's source geometry. You must allocate storage for this parameter. + void ID2D1TransformedGeometry::GetTransform([Out] D2D1_MATRIX_3X2_F* transform) + + + + Default Constructor for a . + + an instance of + + + + + + Retrieves the source geometry of this transformed geometry object. + + void ID2D1TransformedGeometry::GetSourceGeometry([Out] ID2D1Geometry** sourceGeometry) + + + + Retrieves the matrix used to transform the object's source geometry. + + void ID2D1TransformedGeometry::GetTransform([Out] D2D1_MATRIX_3X2_F* transform) + + + + Describes a geometric path that does not contain quadratic bezier curves or arcs. + + ID2D1SimplifiedGeometrySink + + + + Specifies the method used to determine which points are inside the geometry described by this geometry sink and which points are outside. + + + The fill mode defaults to D2D1_FILL_MODE_ALTERNATE. To set the fill mode, call SetFillMode before the first call to {{BeginFigure}}. Not doing will put the geometry sink in an error state. + + The method used to determine whether a given point is part of the geometry. + void SetFillMode([None] D2D1_FILL_MODE fillMode) + + + + Specifies stroke and join options to be applied to new segments added to the geometry sink. + + + After this method is called, the specified segment flags are applied to each segment subsequently added to the sink. The segment flags are applied to every additional segment until this method is called again and a different set of segment flags is specified. + + Stroke and join options to be applied to new segments added to the geometry sink. + void SetSegmentFlags([None] D2D1_PATH_SEGMENT vertexFlags) + + + + Starts a new figure at the specified point. + + + If this method is called while a figure is currently in progress, the interface is invalidated and all future methods will fail. + + The point at which to begin the new figure. + Whether the new figure should be hollow or filled. + void BeginFigure([None] D2D1_POINT_2F startPoint,[None] D2D1_FIGURE_BEGIN figureBegin) + + + + Creates a sequence of lines using the specified points and adds them to the geometry sink. + + A pointer to an array of one or more points that describe the lines to draw. A line is drawn from the geometry sink's current point (the end point of the last segment drawn or the location specified by {{BeginFigure}}) to the first point in the array. if the array contains additional points, a line is drawn from the first point to the second point in the array, from the second point to the third point, and so on. + void AddLines([In, Buffer] const D2D1_POINT_2F* points,[None] UINT pointsCount) + + + + Creates a sequence of cubic Bezier curves and adds them to the geometry sink. + + A pointer to an array of Bezier segments that describes the Bezier curves to create. A curve is drawn from the geometry sink's current point (the end point of the last segment drawn or the location specified by {{BeginFigure}}) to the end point of the first Bezier segment in the array. if the array contains additional Bezier segments, each subsequent Bezier segment uses the end point of the preceding Bezier segment as its start point. + void AddBeziers([In, Buffer] const D2D1_BEZIER_SEGMENT* beziers,[None] UINT beziersCount) + + + + Ends the current figure; optionally, closes it. + + + Calling this method without a matching call to {{BeginFigure}} places the geometry sink in an error state; subsequent calls are ignored, and the overall failure will be returned when the {{Close}} method is called. + + A value that indicates whether the current figure is closed. If the figure is closed, a line is drawn between the current point and the start point specified by {{BeginFigure}}. + void EndFigure([None] D2D1_FIGURE_END figureEnd) + + + + Closes the geometry sink, indicates whether it is in an error state, and resets the sink's error state. + + + Do not close the geometry sink while a figure is still in progress; doing so puts the geometry sink in an error state. For the close operation to be successful, there must be one {{EndFigure}} call for each call to {{BeginFigure}}.After calling this method, the geometry sink might not be usable. Direct2D implementations of this interface do not allow the geometry sink to be modified after it is closed, but other implementations might not impose this restriction. + + HRESULT Close() + + + + Describes a geometric path that can contain lines, arcs, cubic Bezier curves, and quadratic Bezier curves. + + ID2D1GeometrySink + + + + Creates a line segment between the current point and the specified end point and adds it to the geometry sink. + + The end point of the line to draw. + void AddLine([None] D2D1_POINT_2F point) + + + + Creates a cubic Bezier curve between the current point and the specified endpoint. + + A structure that describes the control points and endpoint of the Bezier curve to add. + void AddBezier([In] const D2D1_BEZIER_SEGMENT* bezier) + + + + Creates a quadratic Bezier curve between the current point and the specified endpoint. + + A structure that describes the control point and the endpoint of the quadratic Bezier curve to add. + void AddQuadraticBezier([In] const D2D1_QUADRATIC_BEZIER_SEGMENT* bezier) + + + + Adds a sequence of quadratic Bezier segments as an array in a single call. + + An array of a sequence of quadratic Bezier segments. + void AddQuadraticBeziers([In, Buffer] const D2D1_QUADRATIC_BEZIER_SEGMENT* beziers,[None] UINT beziersCount) + + + + Adds a single arc to the path geometry. + + The arc segment to add to the figure. + void AddArc([In] const D2D1_ARC_SEGMENT* arc) + + + + Populates an object with triangles. + + ID2D1TessellationSink + + + + Copies the specified triangles to the sink. + + An array of structures that describe the triangles to add to the sink. + void AddTriangles([In, Buffer] const D2D1_TRIANGLE* triangles,[None] UINT trianglesCount) + + + + Closes the sink. + + HRESULT Close() + + + + Represents a complex shape that may be composed of arcs, curves, and lines. + + ID2D1PathGeometry + + + + Initializes a new instance of the class. + + The native pointer. + + + + Retrieves the geometry sink that is used to populate the path geometry with figures and segments. + + + Because path geometries are immutable and can only be populated once, it is an error to call Open on a path geometry more than once. Note that the fill mode defaults to . To set the fill mode, call {{SetFillMode}} before the first call to {{BeginFigure}}. Failure to do so will put the geometry sink in an error state. + + When this method returns, geometrySink contains the address of a reference to the geometry sink that is used to populate the path geometry with figures and segments. This parameter is passed uninitialized. + HRESULT ID2D1PathGeometry::Open([Out] ID2D1GeometrySink** geometrySink) + + + + Copies the contents of the path geometry to the specified . + + The sink to which the path geometry's contents are copied. Modifying this sink does not change the contents of this path geometry. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1PathGeometry::Stream([In] ID2D1GeometrySink* geometrySink) + + + + Retrieves the number of segments in the path geometry. + + A reference that receives the number of segments in the path geometry when this method returns. You must allocate storage for this parameter. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1PathGeometry::GetSegmentCount([Out] int* count) + + + + Retrieves the number of figures in the path geometry. + + A reference that receives the number of figures in the path geometry when this method returns. You must allocate storage for this parameter. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1PathGeometry::GetFigureCount([Out] int* count) + + + + Creates an empty . + + an instance of + + + + Copies the contents of the path geometry to the specified . + + The sink to which the path geometry's contents are copied. Modifying this sink does not change the contents of this path geometry. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT Stream([In] ID2D1GeometrySink* geometrySink) + + + + Retrieves the number of segments in the path geometry. + + HRESULT ID2D1PathGeometry::GetSegmentCount([Out] int* count) + + + + Retrieves the number of figures in the path geometry. + + HRESULT ID2D1PathGeometry::GetFigureCount([Out] int* count) + + + + Represents a set of vertices that form a list of triangles. + + ID2D1Mesh + + + + Initializes a new instance of the class. + + The native pointer. + + + + Opens the mesh for population. + + When this method returns, contains a reference to a reference to an that is used to populate the mesh. This parameter is passed uninitialized. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Mesh::Open([Out] ID2D1TessellationSink** tessellationSink) + + + + Create a mesh that uses triangles to describe a shape. + + + To populate a mesh, use its {{Open}} method to obtain an . To draw the mesh, use the render target's {{FillMesh}} method. + + an instance of + HRESULT CreateMesh([Out] ID2D1Mesh** mesh) + + + + Create a mesh that uses triangles to describe a shape and populates it with triangles. + + an instance of + An array of structures that describe the triangles to add to this mesh. + HRESULT CreateMesh([Out] ID2D1Mesh** mesh) + + + + Opens the mesh for population. + + When this method returns, contains a pointer to a pointer to an that is used to populate the mesh. This parameter is passed uninitialized. + HRESULT Open([Out] ID2D1TessellationSink** tessellationSink) + + + + Represents the backing store required to render a layer. + + ID2D1Layer + + + + Initializes a new instance of the class. + + The native pointer. + + + + Gets the size of the layer in device-independent pixels. + + The size of the layer in device-independent pixels. + D2D1_SIZE_F ID2D1Layer::GetSize() + + + + Creates a layer resource that can be used with this render target and its compatible render targets. The new layer has the specified initial size. The layer resource is allocated to the minimum size when {{PushLayer}} is called. + + + Regardless of whether a size is initially specified, the layer automatically resizes as needed. + + an instance of + HRESULT CreateLayer([In, Optional] const D2D1_SIZE_F* size,[Out] ID2D1Layer** layer) + + + + Creates a layer resource that can be used with this render target and its compatible render targets. The new layer has the specified initial size. + + + Regardless of whether a size is initially specified, the layer automatically resizes as needed. + + an instance of + If (0, 0) is specified, no backing store is created behind the layer resource. The layer resource is allocated to the minimum size when {{PushLayer}} is called. + HRESULT CreateLayer([In, Optional] const D2D1_SIZE_F* size,[Out] ID2D1Layer** layer) + + + + Gets the size of the layer in device-independent pixels. + + D2D1_SIZE_F ID2D1Layer::GetSize() + + + + Represents the drawing state of a render target: the antialiasing mode, transform, tags, and text-rendering options. + + ID2D1DrawingStateBlock + + + + Initializes a new instance of the class. + + The native pointer. + + + + Retrieves the antialiasing mode, transform, and tags portion of the drawing state. + + When this method returns, contains the antialiasing mode, transform, and tags portion of the drawing state. You must allocate storage for this parameter. + void ID2D1DrawingStateBlock::GetDescription([Out] D2D1_DRAWING_STATE_DESCRIPTION* stateDescription) + + + + Specifies the antialiasing mode, transform, and tags portion of the drawing state. + + The antialiasing mode, transform, and tags portion of the drawing state. + void ID2D1DrawingStateBlock::SetDescription([In] const D2D1_DRAWING_STATE_DESCRIPTION* stateDescription) + + + + Specifies the text-rendering configuration of the drawing state. + + The text-rendering configuration of the drawing state, or NULL to use default settings. + void ID2D1DrawingStateBlock::SetTextRenderingParams([In, Optional] IDWriteRenderingParams* textRenderingParams) + + + + Retrieves the text-rendering configuration of the drawing state. + + When this method returns, contains the address of a reference to an object that describes the text-rendering configuration of the drawing state. + void ID2D1DrawingStateBlock::GetTextRenderingParams([Out, Optional] IDWriteRenderingParams** textRenderingParams) + + + + Creates an that can be used with the {{SaveDrawingState}} and {{RestoreDrawingState}} methods of a render target. + + an instance of + + + + Creates an that can be used with the {{SaveDrawingState}} and {{RestoreDrawingState}} methods of a render target. + + an instance of + A structure that contains antialiasing, transform, and tags information. + + + + Creates an that can be used with the {{SaveDrawingState}} and {{RestoreDrawingState}} methods of a render target. + + an instance of + Optional text parameters that indicate how text should be rendered. + + + + Creates an that can be used with the {{SaveDrawingState}} and {{RestoreDrawingState}} methods of a render target. + + an instance of + A structure that contains antialiasing, transform, and tags information. + Optional text parameters that indicate how text should be rendered. + + + + Retrieves the antialiasing mode, transform, and tags portion of the drawing state. + + void ID2D1DrawingStateBlock::GetDescription([Out] D2D1_DRAWING_STATE_DESCRIPTION* stateDescription) + + + + Retrieves the text-rendering configuration of the drawing state. + + void ID2D1DrawingStateBlock::GetTextRenderingParams([Out, Optional] IDWriteRenderingParams** textRenderingParams) + + + + Renders drawing instructions to a window. + + ID2D1HwndRenderTarget + + + + Initializes a new instance of the class. + + The native pointer. + + + + Indicates whether the HWND associated with this render target is occluded. + + + Note??If the window was occluded the last time {{EndDraw}} was called, the next time the render target calls CheckWindowState, it will return regardless of the current window state. If you want to use CheckWindowState to determine the current window state, you should call CheckWindowState after every EndDraw call and ignore its return value. This will ensure that your next call to CheckWindowState state will return the actual window state. + + D2D1_WINDOW_STATEA value that indicates whether the HWND associated with this render target is occluded. + D2D1_WINDOW_STATE ID2D1HwndRenderTarget::CheckWindowState() + + + + Changes the size of the render target to the specified pixel size. + + + After this method is called, the contents of the render target's back-buffer are not defined, even if the option was specified when the render target was created. + + The new size of the render target in device pixels. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1HwndRenderTarget::Resize([In] const D2D1_SIZE_U* pixelSize) + + + + Returns the HWND associated with this render target. + + HWNDThe HWND associated with this render target. + void* ID2D1HwndRenderTarget::GetHwnd() + + + + Creates an , a render target that renders to a window. + + + When you create a render target and hardware acceleration is available, you allocate resources on the computer's GPU. By creating a render target once and retaining it as long as possible, you gain performance benefits. Your application should create render targets once and hold onto them for the life of the application or until the {{D2DERR_RECREATE_TARGET}} error is received. When you receive this error, you need to recreate the render target (and any resources it created). + + an instance of + The rendering mode, pixel format, remoting options, DPI information, and the minimum DirectX support required for hardware rendering. For information about supported pixel formats, see {{Supported Pixel Formats and Alpha Modes}}. + The window handle, initial size (in pixels), and present options. + + + + Returns the HWND associated with this render target. + + void* ID2D1HwndRenderTarget::GetHwnd() + + + + Issues drawing commands to a GDI device context. + + ID2D1DCRenderTarget + + + + Initializes a new instance of the class. + + The native pointer. + + + + Binds the render target to the device context to which it issues drawing commands. + + + Before you can render with the DC render target, you must use its BindDC method to associate it with a GDI DC. You do this each time you use a different DC, or the size of the area you want to draw to changes. + + The device context to which the render target issues drawing commands. + The dimensions of the handle to a device context (HDC) to which the render target is bound. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1DCRenderTarget::BindDC([In] const void* hDC,[In] const RECT* pSubRect) + + + + Creates a render target that draws to a Windows Graphics Device Interface (GDI) device context. + + + Before you can render with a DC render target, you must use the render target's {{BindDC}} method to associate it with a GDI DC. Do this for each different DC and whenever there is a change in the size of the area you want to draw to.To enable the DC render target to work with GDI, set the render target's DXGI format to and alpha mode to or D2D1_ALPHA_MODE_IGNORE.Your application should create render targets once and hold on to them for the life of the application or until the render target's {{EndDraw}} method returns the {{D2DERR_RECREATE_TARGET}} error. When you receive this error, recreate the render target (and any resources it created). + + an instance of + The rendering mode, pixel format, remoting options, DPI information, and the minimum DirectX support required for hardware rendering. To enable the device context (DC) render target to work with GDI, set the DXGI format to and the alpha mode to or D2D1_ALPHA_MODE_IGNORE. For more information about pixel formats, see {{Supported Pixel Formats and Alpha Modes}}. + + + + Creates Direct2D resources. + + ID2D1Factory + + + + Initializes a new instance of the class. + + The native pointer. + + + + Forces the factory to refresh any system defaults that it might have changed since factory creation. + + + You should call this method before calling the {{GetDesktopDpi}} method, to ensure that the system DPI is current. + + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Factory::ReloadSystemMetrics() + + + + Retrieves the current desktop dots per inch (DPI). To refresh this value, call {{ReloadSystemMetrics}}. + + + Use this method to obtain the system DPI when setting physical pixel values, such as when you specify the size of a window. + + When this method returns, contains the horizontal DPI of the desktop. You must allocate storage for this parameter. + When this method returns, contains the vertical DPI of the desktop. You must allocate storage for this parameter. + void ID2D1Factory::GetDesktopDpi([Out] float* dpiX,[Out] float* dpiY) + + + + Creates an . + + The coordinates of the rectangle geometry. + When this method returns, contains the address of the reference to the rectangle geometry created by this method. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Factory::CreateRectangleGeometry([In] const D2D1_RECT_F* rectangle,[Out] ID2D1RectangleGeometry** rectangleGeometry) + + + + Creates an . + + The coordinates and corner radii of the rounded rectangle geometry. + When this method returns, contains the address of the reference to the rounded rectangle geometry created by this method. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Factory::CreateRoundedRectangleGeometry([In] const D2D1_ROUNDED_RECT* roundedRectangle,[Out] ID2D1RoundedRectangleGeometry** roundedRectangleGeometry) + + + + Creates an . + + A value that describes the center point, x-radius, and y-radius of the ellipse geometry. + When this method returns, contains the address of the reference to the ellipse geometry created by this method. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Factory::CreateEllipseGeometry([In] const D2D1_ELLIPSE* ellipse,[Out] ID2D1EllipseGeometry** ellipseGeometry) + + + + Creates an , which is an object that holds other geometries. + + + Geometry groups are a convenient way to group several geometries simultaneously so all figures of several distinct geometries are concatenated into one. To create a object, call the CreateGeometryGroup method on the object, passing in the fillMode with possible values of (alternate) and D2D1_FILL_MODE_WINDING, an array of geometry objects to add to the geometry group, and the number of elements in this array. + + A value that specifies the rule that a composite shape uses to determine whether a given point is part of the geometry. + An array containing the geometry objects to add to the geometry group. The number of elements in this array is indicated by the geometriesCount parameter. + The number of elements in geometries. + When this method returns, contains the address of a reference to the geometry group created by this method. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Factory::CreateGeometryGroup([None] D2D1_FILL_MODE fillMode,[In, Buffer] ID2D1Geometry** geometries,[None] int geometriesCount,[Out] ID2D1GeometryGroup** geometryGroup) + + + + Transforms the specified geometry and stores the result as an object. + + + Like other resources, a transformed geometry the inherits the resource space and threading policy of the factory that created it. This object is immutable. When stroking a transformed geometry with the {{DrawGeometry}} method, the stroke width is not affected by the transform applied to the geometry. The stroke width is only affected by the world transform. + + The geometry to transform. + The transformation to apply. + When this method returns, contains the address of the reference to the new transformed geometry object. The transformed geometry stores the result of transforming sourceGeometry by transform. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Factory::CreateTransformedGeometry([In] ID2D1Geometry* sourceGeometry,[In] const D2D1_MATRIX_3X2_F* transform,[Out] ID2D1TransformedGeometry** transformedGeometry) + + + + Creates an empty . + + When this method returns, contains the address to a reference to the path geometry created by this method. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Factory::CreatePathGeometry([Out] ID2D1PathGeometry** pathGeometry) + + + + Creates an that describes start cap, dash pattern, and other features of a stroke. + + A structure that describes the stroke's line cap, dash offset, and other details of a stroke. + An array whose elements are set to the length of each dash and space in the dash pattern. The first element sets the length of a dash, the second element sets the length of a space, the third element sets the length of a dash, and so on. The length of each dash and space in the dash pattern is the product of the element value in the array and the stroke width. + The number of elements in the dashes array. + When this method returns, contains the address of the reference to the stroke style created by this method. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Factory::CreateStrokeStyle([In] const D2D1_STROKE_STYLE_PROPERTIES* strokeStyleProperties,[In, Buffer, Optional] const float* dashes,[None] int dashesCount,[Out] ID2D1StrokeStyle** strokeStyle) + + + + Creates an that can be used with the {{SaveDrawingState}} and {{RestoreDrawingState}} methods of a render target. + + A structure that contains antialiasing, transform, and tags information. + Optional text parameters that indicate how text should be rendered. + When this method returns, contains the address of a reference to the new drawing state block created by this method. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Factory::CreateDrawingStateBlock([In, Optional] const D2D1_DRAWING_STATE_DESCRIPTION* drawingStateDescription,[In, Optional] IDWriteRenderingParams* textRenderingParams,[Out] ID2D1DrawingStateBlock** drawingStateBlock) + + + + Creates an , a render target that renders to a window. + + + When you create a render target and hardware acceleration is available, you allocate resources on the computer's GPU. By creating a render target once and retaining it as long as possible, you gain performance benefits. Your application should create render targets once and hold onto them for the life of the application or until the {{D2DERR_RECREATE_TARGET}} error is received. When you receive this error, you need to recreate the render target (and any resources it created). + + The rendering mode, pixel format, remoting options, DPI information, and the minimum DirectX support required for hardware rendering. For information about supported pixel formats, see {{Supported Pixel Formats and Alpha Modes}}. + The window handle, initial size (in pixels), and present options. + When this method returns, contains the address of the reference to the object created by this method. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Factory::CreateHwndRenderTarget([In] const D2D1_RENDER_TARGET_PROPERTIES* renderTargetProperties,[In] const D2D1_HWND_RENDER_TARGET_PROPERTIES* hwndRenderTargetProperties,[Out] ID2D1HwndRenderTarget** hwndRenderTarget) + + + + Creates a render target that draws to a DirectX Graphics Infrastructure (DXGI) surface. + + + To write to a Direct3D surface, you obtain an and pass it to the {{CreateDxgiSurfaceRenderTarget}} method to create a DXGI surface render target; you can then use the DXGI surface render target to draw 2-D content to the DXGI surface. A DXGI surface render target is a type of . Like other Direct2D render targets, you can use it to create resources and issue drawing commands. The DXGI surface render target and the DXGI surface must use the same DXGI format. If you specify the {{DXGI_FORMAT_UNKOWN}} format when you create the render target, it will automatically use the surface's format. The DXGI surface render target does not perform DXGI surface synchronization. To work with Direct2D, the Direct3D device that provides the must be created with the D3D10_CREATE_DEVICE_BGRA_SUPPORT flag. For more information about creating and using DXGI surface render targets, see the {{Direct2D and Direct3D Interoperability Overview}}. When you create a render target and hardware acceleration is available, you allocate resources on the computer's GPU. By creating a render target once and retaining it as long as possible, you gain performance benefits. Your application should create render targets once and hold onto them for the life of the application or until the render target's {{EndDraw}} method returns the {{D2DERR_RECREATE_TARGET}} error. When you receive this error, you need to recreate the render target (and any resources it created). + + The IDXGISurface to which the render target will draw. + The rendering mode, pixel format, remoting options, DPI information, and the minimum DirectX support required for hardware rendering. For information about supported pixel formats, see {{Supported Pixel Formats and Alpha Modes}}. + When this method returns, contains the address of the reference to the object created by this method. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Factory::CreateDxgiSurfaceRenderTarget([In] IDXGISurface* dxgiSurface,[In] const D2D1_RENDER_TARGET_PROPERTIES* renderTargetProperties,[Out] ID2D1RenderTarget** renderTarget) + + + + Creates a render target that draws to a Windows Graphics Device Interface (GDI) device context. + + + Before you can render with a DC render target, you must use the render target's {{BindDC}} method to associate it with a GDI DC. Do this for each different DC and whenever there is a change in the size of the area you want to draw to. To enable the DC render target to work with GDI, set the render target's DXGI format to and alpha mode to or D2D1_ALPHA_MODE_IGNORE. Your application should create render targets once and hold on to them for the life of the application or until the render target's {{EndDraw}} method returns the {{D2DERR_RECREATE_TARGET}} error. When you receive this error, recreate the render target (and any resources it created). + + The rendering mode, pixel format, remoting options, DPI information, and the minimum DirectX support required for hardware rendering. To enable the device context (DC) render target to work with GDI, set the DXGI format to and the alpha mode to or D2D1_ALPHA_MODE_IGNORE. For more information about pixel formats, see {{Supported Pixel Formats and Alpha Modes}}. + When this method returns, dcRenderTarget contains the address of the reference to the created by the method. + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1Factory::CreateDCRenderTarget([In] const D2D1_RENDER_TARGET_PROPERTIES* renderTargetProperties,[Out] ID2D1DCRenderTarget** dcRenderTarget) + + + + Default Constructor for a . + + + + + Default Constructor for a . + + + + + Default Constructor for a . + + + + + Retrieves the current desktop dots per inch (DPI). To refresh this value, call {{ReloadSystemMetrics}}. + + + Use this method to obtain the system DPI when setting physical pixel values, such as when you specify the size of a window. + + + + + Describes a geometric path that does not contain quadratic bezier curves or arcs. + + ID2D1SimplifiedGeometrySink + + + + Initializes a new instance of the class. + + The native pointer. + + + + Specifies the method used to determine which points are inside the geometry described by this geometry sink and which points are outside. + + + The fill mode defaults to D2D1_FILL_MODE_ALTERNATE. To set the fill mode, call SetFillMode before the first call to {{BeginFigure}}. Not doing will put the geometry sink in an error state. + + The method used to determine whether a given point is part of the geometry. + void ID2D1SimplifiedGeometrySink::SetFillMode([None] D2D1_FILL_MODE fillMode) + + + + Specifies stroke and join options to be applied to new segments added to the geometry sink. + + + After this method is called, the specified segment flags are applied to each segment subsequently added to the sink. The segment flags are applied to every additional segment until this method is called again and a different set of segment flags is specified. + + Stroke and join options to be applied to new segments added to the geometry sink. + void ID2D1SimplifiedGeometrySink::SetSegmentFlags([None] D2D1_PATH_SEGMENT vertexFlags) + + + + Starts a new figure at the specified point. + + + If this method is called while a figure is currently in progress, the interface is invalidated and all future methods will fail. + + The point at which to begin the new figure. + Whether the new figure should be hollow or filled. + void ID2D1SimplifiedGeometrySink::BeginFigure([None] D2D1_POINT_2F startPoint,[None] D2D1_FIGURE_BEGIN figureBegin) + + + + Creates a sequence of lines using the specified points and adds them to the geometry sink. + + A reference to an array of one or more points that describe the lines to draw. A line is drawn from the geometry sink's current point (the end point of the last segment drawn or the location specified by {{BeginFigure}}) to the first point in the array. if the array contains additional points, a line is drawn from the first point to the second point in the array, from the second point to the third point, and so on. + The number of points in the points array. + void ID2D1SimplifiedGeometrySink::AddLines([In, Buffer] const D2D1_POINT_2F* points,[None] int pointsCount) + + + + Creates a sequence of cubic Bezier curves and adds them to the geometry sink. + + A reference to an array of Bezier segments that describes the Bezier curves to create. A curve is drawn from the geometry sink's current point (the end point of the last segment drawn or the location specified by {{BeginFigure}}) to the end point of the first Bezier segment in the array. if the array contains additional Bezier segments, each subsequent Bezier segment uses the end point of the preceding Bezier segment as its start point. + The number of Bezier segments in the beziers array. + void ID2D1SimplifiedGeometrySink::AddBeziers([In, Buffer] const D2D1_BEZIER_SEGMENT* beziers,[None] int beziersCount) + + + + Ends the current figure; optionally, closes it. + + + Calling this method without a matching call to {{BeginFigure}} places the geometry sink in an error state; subsequent calls are ignored, and the overall failure will be returned when the {{Close}} method is called. + + A value that indicates whether the current figure is closed. If the figure is closed, a line is drawn between the current point and the start point specified by {{BeginFigure}}. + void ID2D1SimplifiedGeometrySink::EndFigure([None] D2D1_FIGURE_END figureEnd) + + + + Closes the geometry sink, indicates whether it is in an error state, and resets the sink's error state. + + + Do not close the geometry sink while a figure is still in progress; doing so puts the geometry sink in an error state. For the close operation to be successful, there must be one {{EndFigure}} call for each call to {{BeginFigure}}. After calling this method, the geometry sink might not be usable. Direct2D implementations of this interface do not allow the geometry sink to be modified after it is closed, but other implementations might not impose this restriction. + + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1SimplifiedGeometrySink::Close() + + + + Describes a geometric path that can contain lines, arcs, cubic Bezier curves, and quadratic Bezier curves. + + ID2D1GeometrySink + + + + Initializes a new instance of the class. + + The native pointer. + + + + Creates a line segment between the current point and the specified end point and adds it to the geometry sink. + + The end point of the line to draw. + void ID2D1GeometrySink::AddLine([None] D2D1_POINT_2F point) + + + + Creates a cubic Bezier curve between the current point and the specified end point. + + A structure that describes the control points and end point of the Bezier curve to add. + void ID2D1GeometrySink::AddBezier([In] const D2D1_BEZIER_SEGMENT* bezier) + + + + Creates a quadratic Bezier curve between the current point and the specified endpoint. + + A structure that describes the control point and the endpoint of the quadratic Bezier curve to add. + void ID2D1GeometrySink::AddQuadraticBezier([In] const D2D1_QUADRATIC_BEZIER_SEGMENT* bezier) + + + + Adds a sequence of quadratic Bezier segments as an array in a single call. + + An array of a sequence of quadratic Bezier segments. + A value indicating the number of quadratic Bezier segments in beziers. + void ID2D1GeometrySink::AddQuadraticBeziers([In, Buffer] const D2D1_QUADRATIC_BEZIER_SEGMENT* beziers,[None] int beziersCount) + + + + Adds a single arc to the path geometry. + + The arc segment to add to the figure. + void ID2D1GeometrySink::AddArc([In] const D2D1_ARC_SEGMENT* arc) + + + + Populates an object with triangles. + + ID2D1TessellationSink + + + + Initializes a new instance of the class. + + The native pointer. + + + + Copies the specified triangles to the sink. + + An array of structures that describe the triangles to add to the sink. + The number of triangles to copy from the triangles array. + void ID2D1TessellationSink::AddTriangles([In, Buffer] const D2D1_TRIANGLE* triangles,[None] int trianglesCount) + + + + Closes the sink and returns its error status. + + If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT ID2D1TessellationSink::Close() + + + + Contains the data format and alpha mode for a bitmap or render target. + + + For more information about the pixel formats and alpha modes supported by each render target, see {{Supported Pixel Formats and Alpha Modes}}. + + D2D1_PIXEL_FORMAT + + + + A value that specifies the size and arrangement of channels in each pixel. + + DXGI_FORMAT format + + + + A value that specifies whether the alpha channel is using pre-multiplied alpha, straight alpha, whether it should be ignored and considered opaque, or whether it is unkown. + + D2D1_ALPHA_MODE alphaMode + + + + Initializes a new instance of the struct. + + A value that specifies the size and arrangement of channels in each pixel. + A value that specifies whether the alpha channel is using pre-multiplied alpha, straight alpha, whether it should be ignored and considered opaque, or whether it is unkown. + + + + Contains the position and color of a gradient stop. + + + Gradient stops can be specified in any order if they are at different positions. Two stops may share a position. In this case, the first stop specified is treated as the "low" stop (nearer 0.0f) and subsequent stops are treated as "higher" (nearer 1.0f). This behavior is useful if a caller wants an instant transition in the middle of a stop. Typically, there are at least two points in a collection, although creation with only one stop is permitted. For example, one point is at position 0.0f, another point is at position 1.0f, and additional points are distributed in the [0, 1] range. Where the gradient progression is beyond the range of [0, 1], the stops are stored, but may affect the gradient. When drawn, the [0, 1] range of positions is mapped to the brush, in a brush-dependent way. For details, see and . Gradient stops with a position outside the [0, 1] range cannot be seen explicitly, but they can still affect the colors produced in the [0, 1] range. For example, a two-stop gradient {{0.0f, Black}, {2.0f, White}} is indistinguishable visually from {{0.0f, Black}, {1.0f, Mid-level gray}}. Also, the colors are clamped before interpolation. + + D2D1_GRADIENT_STOP + + + + A value that indicates the relative position of the gradient stop in the brush. This value must be in the [0.0f, 1.0f] range if the gradient stop is to be seen explicitly. + + float position + + + + The color of the gradient stop. + + D2D1_COLOR_F color + + + + Describes the opacity and transformation of a brush. + + + This structure is used when creating a brush. For convenience, Direct2D provides the {{D2D1::BrushProperties}} function for creating D2D1_BRUSH_PROPERTIES structures. After creating a brush, you can change its opacity or transform by calling the {{SetOpacity}} or {{SetTransform}} methods. + + D2D1_BRUSH_PROPERTIES + + + + A value between 0.0f and 1.0f, inclusive, that specifies the degree of opacity of the brush. + + float opacity + + + + The transformation that is applied to the brush. + + D2D1_MATRIX_3X2_F transform + + + + Describes the extend modes and the interpolation mode of an . + + D2D1_BITMAP_BRUSH_PROPERTIES + + + + A value that describes how the brush horizontally tiles those areas that extend past its bitmap. + + D2D1_EXTEND_MODE extendModeX + + + + A value that describes how the brush vertically tiles those areas that extend past its bitmap. + + D2D1_EXTEND_MODE extendModeY + + + + A value that specifies how the bitmap is interpolated when it is scaled or rotated. + + D2D1_BITMAP_INTERPOLATION_MODE interpolationMode + + + + Contains the starting point and endpoint of the gradient axis for an . + + + Use this method when creating new objects with the {{CreateLinearGradientBrush}} method. For convenience, Direct2D provides the {{D2D1::LinearGradientBrushProperties}} helper function for creating new D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES structures. The following illustration shows how a linear gradient changes as you change its start and end points. For the first gradient, the start point is set to (0,0) and the end point to (150, 50); this creates a diagonal gradient that starts at the upper-left corner and extends to the lower-right corner of the area being painted. When you set the start point to (0, 25) and the end point to (150, 25), a horizontal gradient is created. Similarly, setting the start point to (75, 0) and the end point to (75, 50) creates a vertical gradient. Setting the start point to (0, 50) and the end point to (150, 0) creates a diagonal gradient that starts at the lower-left corner and extends to the upper-right corner of the area being painted. ? Illustration of four gradients with different axes ? + + D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES + + + + In the brush's coordinate space, the starting point of the gradient axis. + + D2D1_POINT_2F startPoint + + + + In the brush's coordinate space, the endpoint of the gradient axis. + + D2D1_POINT_2F endPoint + + + + Contains the gradient origin offset and the size and position of the gradient ellipse for an . + + + Different values for center, gradientOriginOffset, radiusX and/or radiusY produce different gradients. The following illustration shows several radial gradients that have different gradient origin offsets, creating the appearance of the light illuminating the circles from different angles. ? Illustration of four circles with radial gradients that have different origin offsets ? For convenience, Direct2D provides the {{D2D1::RadialGradientBrushProperties}} function for creating new D2D1_RADIAL_GRADIENT_BRUSH structures. + + D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES + + + + In the brush's coordinate space, the center of the gradient ellipse. + + D2D1_POINT_2F center + + + + In the brush's coordinate space, the offset of the gradient origin relative to the gradient ellipse's center. + + D2D1_POINT_2F gradientOriginOffset + + + + In the brush's coordinate space, the x-radius of the gradient ellipse. + + float radiusX + + + + In the brush's coordinate space, the y-radius of the gradient ellipse. + + float radiusY + + + + Represents a cubic bezier segment drawn between two points. + + + A cubic Bezier curve is defined by four points: a start point, an end point (point3), and two control points (point1 and point2). A Bezier segment does not contain a property for the starting point of the curve; it defines only the end point. The beginning point of the curve is the current point of the path to which the Bezier curve is added. The two control points of a cubic Bezier curve behave like magnets, attracting portions of what would otherwise be a straight line toward themselves and producing a curve. The first control point, point1, affects the beginning portion of the curve; the second control point, point2, affects the ending portion of the curve. Note??The curve doesn't necessarily pass through either of the control points; each control point moves its portion of the line toward itself, but not through itself. + + D2D1_BEZIER_SEGMENT + + + + The first control point for the Bezier segment. + + D2D1_POINT_2F point1 + + + + The second control point for the Bezier segment. + + D2D1_POINT_2F point2 + + + + The end point for the Bezier segment. + + D2D1_POINT_2F point3 + + + + Contains the three vertices that describe a triangle. + + D2D1_TRIANGLE + + + + The first vertex of a triangle. + + D2D1_POINT_2F point1 + + + + The second vertex of a triangle. + + D2D1_POINT_2F point2 + + + + The third vertex of a triangle. + + D2D1_POINT_2F point3 + + + + Describes an elliptical arc between two points. + + D2D1_ARC_SEGMENT + + + + The end point of the arc. + + D2D1_POINT_2F point + + + + The x-radius and y-radius of the arc. + + D2D1_SIZE_F size + + + + A value that specifies how many degrees in the clockwise direction the ellipse is rotated relative to the current coordinate system. + + float rotationAngle + + + + A value that specifies whether the arc sweep is clockwise or counterclockwise. + + D2D1_SWEEP_DIRECTION sweepDirection + + + + A value that specifies whether the given arc is larger than 180 degrees. + + D2D1_ARC_SIZE arcSize + + + + Contains the control point and end point for a quadratic Bezier segment. + + D2D1_QUADRATIC_BEZIER_SEGMENT + + + + The control point of the quadratic Bezier segment. + + D2D1_POINT_2F point1 + + + + The end point of the quadratic Bezier segment. + + D2D1_POINT_2F point2 + + + + Contains the dimensions and corner radii of a rounded rectangle. + + + Each corner of the rectangle specified by the rect is replaced with a quarter ellipse, with a radius in each direction specified by radiusX and radiusY. If the radiusX is greater than or equal to half the width of the rectangle, and the radiusY is greater than or equal to one-half the height, the rounded rectangle is an ellipse with the same width and height of the rect. Even when both radiuX and radiusY are zero, the rounded rectangle is different from a rectangle., When stroked, the corners of the rounded rectangle are roundly joined, not mitered (square). + + D2D1_ROUNDED_RECT + + + + The coordinates of the rectangle. + + D2D1_RECT_F rect + + + + The x-radius for the quarter ellipse that is drawn to replace every corner of the rectangle. + + float radiusX + + + + The y-radius for the quarter ellipse that is drawn to replace every corner of the rectangle. + + float radiusY + + + + Describes the stroke that outlines a shape. + + + The following illustration shows different dashOffset values for the same custom dash style. ? Illustration of four dashes with the same style and different dashOffset values ? + + D2D1_STROKE_STYLE_PROPERTIES + + + + The cap applied to the start of all the open figures in a stroked geometry. + + D2D1_CAP_STYLE startCap + + + + The cap applied to the end of all the open figures in a stroked geometry. + + D2D1_CAP_STYLE endCap + + + + The shape at either end of each dash segment. + + D2D1_CAP_STYLE dashCap + + + + A value that describes how segments are joined. This value is ignored for a vertex if the segment flags specify that the segment should have a smooth join. + + D2D1_LINE_JOIN lineJoin + + + + The limit of the thickness of the join on a mitered corner. This value is always treated as though it is greater than or equal to 1.0f. + + float miterLimit + + + + A value that specifies whether the stroke has a dash pattern and, if so, the dash style. + + D2D1_DASH_STYLE dashStyle + + + + A value that specifies an offset in the dash sequence. A positive dash offset value shifts the dash pattern, in units of stroke width, toward the start of the stroked geometry. A negative dash offset value shifts the dash pattern, in units of stroke width, toward the end of the stroked geometry. + + float dashOffset + + + + Contains the content bounds, mask information, opacity settings, and other options for a layer resource. + + D2D1_LAYER_PARAMETERS + + + + The content bounds of the layer. Content outside these bounds is not guaranteed to render. + + D2D1_RECT_F contentBounds + + + + The geometric mask specifies the area of the layer that is composited into the render target. + + ID2D1Geometry* geometricMask + + + + A value that specifies the antialiasing mode for the geometricMask. + + D2D1_ANTIALIAS_MODE maskAntialiasMode + + + + A value that specifies the transform that is applied to the geometric mask when composing the layer. + + D2D1_MATRIX_3X2_F maskTransform + + + + An opacity value that is applied uniformly to all resources in the layer when compositing to the target. + + float opacity + + + + A brush that is used to modify the opacity of the layer. The brush + is mapped to the layer, and the alpha channel of each mapped brush pixel is multiplied against the corresponding layer pixel. + + ID2D1Brush* opacityBrush + + + + A value that specifies whether the layer intends to render text with ClearType antialiasing. + + D2D1_LAYER_OPTIONS layerOptions + + + + Contains rendering options (hardware or software), pixel format, DPI information, remoting options, and Direct3D support requirements for a render target. + + + Use this structure when creating a render target, or use it with the method to check the properties supported by an existing render target. As a convenience, Direct2D provides the {{D2D1::RenderTargetProperties}} helper function for creating D2D1_RENDER_TARGET_PROPERTIES structures. An easy way to create a D2D1_RENDER_TARGET_PROPERTIES structure that works for most render targets is to call the function without specifying any parameters. Doing so creates a D2D1_RENDER_TARGET_PROPERTIES structure that has its fields set to default values. For more information, see {{D2D1::RenderTargetProperties}}. Not all render targets support hardware rendering. For a list, see the {{Render Targets Overview}}. Using Default DPI Settings To use the default DPI, set dpiX and dpiY to 0. The default DPI varies depending on the render target: For a compatible render target, the default DPI is the DPI of the parent render target. For a , the default DPI is the system DPI obtained from the render target's . For other render targets, the default DPI is 96. To use the default DPI setting, both dpiX and dpiY must be set to 0. Setting only one value to 0 causes an {{E_INVALIDARG}} error when attempting to create a render target. + + D2D1_RENDER_TARGET_PROPERTIES + + + + A value that specifies whether the render target should force hardware or software rendering. A value of specifies that the render target should use hardware rendering if it is available; otherwise, it uses software rendering. Note that WIC bitmap render targets do not support hardware rendering. + + D2D1_RENDER_TARGET_TYPE type + + + + The pixel format and alpha mode of the render target. You can use the {{D2D1::PixelFormat}} function to create a pixel format that specifies that Direct2D should select the pixel format and alpha mode for you. For a list of pixel formats and alpha modes supported by each render target, see {{Supported Pixel Formats and Alpha Modes}}. + + D2D1_PIXEL_FORMAT pixelFormat + + + + The horizontal DPI of the render target. To use the default DPI, set dpiX and dpiY to 0. For more information, see the Remarks section. + + float dpiX + + + + The vertical DPI of the render target. To use the default DPI, set dpiX and dpiY to 0. For more information, see the Remarks section. + + float dpiY + + + + A value that specifies how the render target is remoted and whether it should be GDI-compatible. Set to to create a render target that is not compatible with GDI and uses Direct3D command-stream remoting if it is available. + + D2D1_RENDER_TARGET_USAGE usage + + + + A value that specifies the minimum Direct3D feature level required for hardware rendering. If the specified minimum level is not available, the render target uses software rendering if the type member is set to ; if type is set to to D2D1_RENDER_TARGET_TYPE_HARDWARE, render target creation fails. A value of indicates that Direct2D should determine whether the Direct3D feature level of the device is adequate. This field is used only when creating and objects. + + D2D1_FEATURE_LEVEL minLevel + + + + Initializes a new instance of the struct. + + The pixel format and alpha mode of the render target. You can use the {{D2D1::PixelFormat}} function to create a pixel format that specifies that Direct2D should select the pixel format and alpha mode for you. For a list of pixel formats and alpha modes supported by each render target, see {{Supported Pixel Formats and Alpha Modes}}. + + + + Initializes a new instance of the struct. + + A value that specifies whether the render target should force hardware or software rendering. A value of specifies that the render target should use hardware rendering if it is available; otherwise, it uses software rendering. Note that WIC bitmap render targets do not support hardware rendering. + The pixel format and alpha mode of the render target. You can use the {{D2D1::PixelFormat}} function to create a pixel format that specifies that Direct2D should select the pixel format and alpha mode for you. For a list of pixel formats and alpha modes supported by each render target, see {{Supported Pixel Formats and Alpha Modes}}. + The horizontal DPI of the render target. To use the default DPI, set dpiX and dpiY to 0. For more information, see the Remarks section. + The vertical DPI of the render target. To use the default DPI, set dpiX and dpiY to 0. For more information, see the Remarks section. + A value that specifies how the render target is remoted and whether it should be GDI-compatible. Set to to create a render target that is not compatible with GDI and uses Direct3D command-stream remoting if it is available. + A value that specifies the minimum Direct3D feature level required for hardware rendering. If the specified minimum level is not available, the render target uses software rendering if the type member is set to ; if type is set to to D2D1_RENDER_TARGET_TYPE_HARDWARE, render target creation fails. A value of indicates that Direct2D should determine whether the Direct3D feature level of the device is adequate. This field is used only when creating and objects. + + + + Contains the HWND, pixel size, and presentation options for an . + + + Use this structure when you call the {{CreateHwndRenderTarget}} method to create a new . For convenience, Direct2D provides the {{D2D1::HwndRenderTargetProperties}} function for creating new D2D1_HWND_RENDER_TARGET_PROPERTIES structures. + + D2D1_HWND_RENDER_TARGET_PROPERTIES + + + + The HWND to which the render target issues the output from its drawing commands. + + void* hwnd + + + + The size of the render target, in pixels. + + D2D1_SIZE_U pixelSize + + + + A value that specifies whether the render target retains the frame after it is presented and whether the render target waits for the device to refresh before presenting. + + D2D1_PRESENT_OPTIONS presentOptions + + + + Describes the drawing state of a render target. + + D2D1_DRAWING_STATE_DESCRIPTION + + + + The antialiasing mode for subsequent nontext drawing operations. + + D2D1_ANTIALIAS_MODE antialiasMode + + + + The antialiasing mode for subsequent text and glyph drawing operations. + + D2D1_TEXT_ANTIALIAS_MODE textAntialiasMode + + + + A label for subsequent drawing operations. + + D2D1_TAG tag1 + + + + A label for subsequent drawing operations. + + D2D1_TAG tag2 + + + + The transformation to apply to subsequent drawing operations. + + D2D1_MATRIX_3X2_F transform + + + + Contains the debugging level of an object. + + + To enable debugging, you must install the {{Direct2D Debug Layer}}. + + D2D1_FACTORY_OPTIONS + + + + The debugging level of the object. + + D2D1_DEBUG_LEVEL debugLevel + + + + Internal GeometrySink Callback + + + + + Internal SimplifiedGeometrySink Callback + + + + + Internal TessellationSink Callback + + + + + Direct2D Matrix 3x2. Use and explicit cast to . + + + + + Element (1,1) + + + + + Element (1,2) + + + + + Element (2,1) + + + + + Element (2,2) + + + + + Element (3,1) + + + + + Element (3,2) + + + + + Performs an explicit conversion from to . + + The matrix. + The result of the conversion. + + + + Gets the identity matrix. + + The identity matrix. + + + diff --git a/Libs/SharpDX.Direct3D10.dll b/Libs/SharpDX.Direct3D10.dll new file mode 100644 index 0000000000000000000000000000000000000000..83e257e6276b33feee9b1cd09fbdb02007075716 GIT binary patch literal 139776 zcmeGF378ed^#+Vrci(+x?yStP$qd_gnT1US6;M<}L{LzK5k!$iKvB>kE`f_Eibf$A zx8Ra!Tp}@=n8YN;BrXw6jO$NK+zIYWOeBfMHTb>nsp`IU``#G_v;6Ut{t0&LARC!9N2>yTZg;ICpmw#ggb`Dk}IbDBGTHTd=yzkx4q{sVCTeP^n zVcF?R7oL8?DGl>ZIQ7(}%Nyn{XgK{Vr#37;wPD;5M>U+XbpC?DWo4-WhV+z!m73&u zYRoCePWEftrrf?IPC}{fu2T5n->Q)aH%Jg*tPUfJeDlx$RjUz+fBf^**b9`Zkbk*f zgX%1*1$2*Kcq|IVOr-rY$5o}k9~mbl@&#ut2Y!AX>P4Eg z)$r|SL-d@%r?;Ozj}hd}=dovg#<55leENbVOOcVhD)6kBrJ*3-flRjl=1{KqBX6#X zs+#T4f$@%VBzD(9KiA8kY^n)GtB1NOg%Z}bC)oW(k=-kMPvz6?B~{I5KWP(UPB|Q1;0u1mq{Zw6|1Xjhj>#ZZhUD8 z8{uWj5Z|~p*%)66JxJ~78EN!>9k1HkgQKy zWzeFqfKav??dgkOux|RzFPpN;LSB{VWXbQT{`f6te%&EZw3t^81zmbB#plMPyC`F5 zarID7>@d4EbU^s&efBIn$12r^9xH^RpdAvP(NiP|Hk@WAHES=pJfEjcLbki?qY;b<>WA zO*%M;;BvwfIi2}0r>4HWxU!A7#2>co7j>;&!)VuFV3KsQdOR=J((jmnzh$% zE43Lg^!CGVuTJTOIV(<#`i>TGo~*=x%0Mq*+GDi)Mn)d>HJl!$S!afQ-F3*?%Zp_8 z2eTY|5j7F{p$C;FsY=ym#v-vKwiH^DLTjJ^sSLU=RaRRaX|9PRDkB+mLTV|bnyQS{ zwN*zdBgx@!#g;;3sm3_!X>!YsqxDaEdN=3xJXXm>L!?iZM!2F(wU$5MYwL?IuD#uWc+vZDnIsvr% zhG;`QF&(&7ZaR{MwT>VV%|e$Lh-G0-5r|}A@$nnYrtq6c!T3z*G&-1aM*p%$s0r*4Dgygo#zJid&J`OgavY<> z2fCRCNW-n+NHwzXsMi!`Kji(2Iy^iq`K2!R?0emOmuah#C}* zrX!gHbp<2b+C02^Xo9v@`wpJaiq!8`4)sErKAMl?jdJ z5sSr_{u4xFiKQR&r!rQXY=>5+mVPQ|ytXo;@y`WM)K*3{zJs{dJx{>`s@=8jL4TJZ z$%{i_@$X2JCqkPdezxm9McbNzuBMhk>ELW<)}usYEaTGtHM$Wmb0Q)@+#8xyu-)

3BK;`DYd|$G$Fv>>)mLvJ~K)Gzhsd|5dt?DD4((YOk2L6p~LZ1&b+fDG~vZ zEtOfQt5M%Z=5(YTH6o>xteF4Tv54^%WG?q$o6qujbm=Ci+Al?>3>I@S*F^l05mT** zKQZDcE8=ZN9BoBxV#Ew90tyt%9Aib?%ZOP3O?})Ia0VjeD=Pu;gE+W~I!*#Q4lbaM zlYoxHRH@@6pyMz->NpALI85j|P69d(-J|0qAaR*fG*6kO{Ka_9oQgmrq`TJmJ%L|s zdp_t9xazq)zQwU!9;7o5^#a`_e*sDAhhHXb*_&ov<}xdzpRL@=)}phiznXk439n$a z6lwKpVUYde-K^rREFQ9z_NoeojecFJS_!TP11V2rz*(v#fdK0Em!4kHdZC?E{+47~ zdrkHdE*&?dT1&4F!t#7dS96~-k*uO*bK$h4-P%c?mAio)`ddYXDWCuRL|1FdqL_9!Fj?%`dKeY7PJEl@yP#~Ur;@GD51^V%Vxy(du7g_OS&0d2@l z`+Hd>DF-E>uaRs+vC;Kn;2U>-pT18zR$T6-)=JAc4ocukQ`hzS&@qiE}Ga%%M zeQ|IBjm}2YIEx~tkwTG#eX)bB0%Bi6_Gf%Jo$Xo$p5S3tVp#;6Mf>As&_^llca(T# zx`&cmOooCnS>*%+>JY1fK$xYq+sdMGZHnM{Vw)`94uuqTs&Yj<3DMQKS`A(x=gP>y z)_7yx`U~M91Z>1=HxREjgD|-z(h{wVY-!dR#4K2xOz40UI9Y|UnTEe6L%0;pk^^Y-e^POau8=kpw4@e-J(l4xlAex+ZJBlU1khPGfA>Y37|dLT;OBX&J0 z^&Hx>AKDXbNk!2uS;)CLRwuuyXiH!AP&B>)9wU2*shQpV9zuSrhnVK~kS&mCfz6}` zVRhM5i+!x1tuBkU)MI_Bdrhjw^N*m{So@plSg6;6R{FiRi?Te@Vy5FhJGYoDV`>p( zITkJO_p!M_y%$&(EjD`}@Pe#4<0z}TV7@Iyu@NX13C&1WYCkNNe~(Bod09GME~!;B8BKbQjGCsDwe4A;} zJqS7EnIWH&8BbH&EX;j;=I58k{%qi;&9Vp#EJlEPcvy_mUzPE52h54?A&bhf78NdL z#K$d@aW@`lq$FzeU!Hm=%1wg=&B~y&$enf#OD(aN8wT0&qq62 z7aV65FTO5_`g@>KEmnrPHPP`_;lTFfJ(v|ei0~NzpHWx3Ufp`wZ#RVrlE0C231gWJ z=wDxF<|8lG*_9C(cXXDUVgMVDPKh5Vtu1RF7E4BwLL+l7EYFSc09^z0+lc_ZfM~L= ztt^S+!ym!Esw-<#dn4Chn^t3O`Ze%85j@v!!4z~L4E?qp zy|FRpJinv7B%Z1*ZO+6JkQJk5wnY=yVCqU-V=q);pOurSYb#A~mUucHsolUPm!+dR z5X@7NSaJ*83BUL4J>tX20R4t-Wt8O$I!{qAGuTV2FSELE5(qS@^GrFviYhBdo#f!y ziK?-v16=3%6_)0=TE!@;@M78bR7WMsnBi}p7=wK@5v(q^F}Dv*xqRS%KU zxDiq!ETd?P7i)HFF`8N;$-LE1x^Qy$+d0@`*b-&5WfG_Kv2eRElOvDr#MAgA)1>yl zx)&t+>$e+yuZ=zX3w`F{aI_cygZ&2I3P67GEs3Cahgd8ff$Vxzhb8H+6Vd7H7w+-Z zQsCj|s`bMya_kcQVAUQ2+&`#7`6)<^=+TD(6I;4B#s~+fpANf@^d%gfl8!Y+Uiy)e zeqxXg-`=FhWZ#?gVGHVX6|vgLjj^Thvt=A|51<=(U>%Z2s?mAiAm`;_J(5SN(s?jn znmiFT19Xl;9HT0V;M>s7L|P7nCCiPILOT?J{;(^+OAfnHIVDpJaR<)4c(DGOVj7$GF@{^Jb04MJPk$ixG^u0xu5(5 znMEd@(@RL6;`HKPF?#7Db^9_aMkmLP>tQ&NL)7Wf)~RFtc4|QejO(?jC;ge92d&IJ zkl#qqAwBk2eqLP-Gms_t1a=W1a2W z!>bD(1KFqdjsxFp(;rQxMIU(hb=t@Dl^O$HT$1@Ry40=vIf>KIg25rs;hw zE<2v4E1_-r=>Y5K(ldvBEy5iwU9t!A|0FMi9)@GjK z_$xzR%xBE)Nh$=uF+e&eSdm`!vDuG`C$2Zx;$IK^8EGAC5&YrWxo75QlE9h8bZ!=Y(WO{!aPqgGw5~2 z&kvv9V>$L2)-Y-TXd9Q*=E+|r!R3q>ox|+Mws2Q4X_laknkMYGPt%suPHEO#3X-F_ zQ{Q~FRg8{c*rW8fJcK`t1Flzn{-n)biRlS5gU9ipp@XS=j8&J`VXjOeP_~`4@$A#5 zEo~Rt4DFouejU+ffA1IgfpK}hYHaX-WPN7LVZ?vHYTL|{&>rf`6P?&hV=@cWjJ5~m z{rTd*!fSoCB{jqB|D@iU;`N@1_MQxx<*k~{+670uayv4+hstB8cT_YUizC{Fy3A}V zoC!i{f%_->^<0nLN4vSx@zQM7Tx`6oG}~(!FLBl7_UvI%Wj}n0_Lzq}H|Doz7kJq7 z-{-;XUFPw?@wfl~aQxY>hf(RSj6ZuF!+w?igFX7Mjz9Z=i_h!-Wc=9&7p-yMWqr;3 z`?^wGUw1nG23a*18-M=Oja?gmO%~NJIsS_2{w~>omVcjzJ>l2DuPhjUW3BOr=KWW7 zy1pXRj;5~pS(R2X8GzvPe=-(ot%|L&@L!ixUGaLmJO+n`%72MDqnN&QVGbN-)m&^0 zVyUE;H@l?&BP^=yhcD5d;x=U$=D?BvJ`ct1fPVJ~+n4@X`V@vLU7DpAA`m(YNB!n{9&v#ovnbEgtOJ&3~=r9O))0Ug)i z$4NlP_4VT#`D%xXb}GJ9BX?0>5~}CWhn5vH@w{$YPzDBp%z!8P^0~bwY#b zFF3|tA-%*;PnmSS%fbD!Q;j^z7!QH)oNQ^3N6Q8^`p@%>n{9jNdm&Z7KbSjpMw_Ge z!nhvRg-lV~vA}|v$L2Uzu)R^_e4g!2>|#B(Q()BtVcPW++kPpslvvt98>4*2Qt&)E z=V99`)PP38DaQlRPjXNu?^$d|=N;{X$ZS|K+3R=VWG_@dQGqI$cj3-MC^S&GF93bh zd#6@@j;kWsecj3%SIgMXP=IRajz6wiKvSNZ?C5rGv2hh%tZ`Twz0IS2nxS25(S|SF z$+NOB2pmjRy&~2|lHGBg`-Xf7#lyLH>P-YQ%zpXu7F4}$&x)YKs zEX1~vxNVP?o3{0`+Gfe^hGKHFwTcr52QMQuNJI|rEBH*) z=t*cIUto!5`W43GB^E!Pb5UQ&>no_&e`h5fsc%5nH(|aCX_itG`QC~!fP>7L-G%l< zzPl2N+t0k;f|n>H6P_W+`z=1sXPP}xuh=3_Ix50?@rFwbd74qTJP)Ic*%rzecCUpM zlIL~6&j8Oj4T$3j`aImh2$+MOddwGnvTI6ob{=l7HQz;1i44io@RsPW%zSR0htubU z;H$`ahu^ZZA;?8|Y9%c!dR}OrRaxG7p~WZ`J}-pfCyH*>sn0E(g*x->a{YXZt}&R9 z8TJw*wKbU`lq17Y6Xsr1Bhp>ck*O&nZy-kG1;i-cSwlncDh)NlpQu7}(g@N-AC1&~ zq~{|TDzPJbBa-uxKTn-);`cG}D0iSPr=QP$73sBk4YKDbwnttBGS5sqDifZZ^2>B? z>+QL!V_Q$%EVT7ewJ&5D0hf3$5KpdL&vbooGQ^(F0_vfIA)H5P%V2pz^R;acS0Ytj zj&1+088j?62IaD>KQo@ALQ7H~meJwKw$;IwrA4D8mN^84%>H#$-uXPIfQP)7*KP~scdsQ&U1Zh}IusvO%WqWm<(rN);n7~3Z&3l_L*Pb71q53>v{_I4i zd51-EJdj3Sdphz3>=%qW@&%%NCr%ZPk9zyHqr3sKAG}PIN#WJSQ}q~&i0xg&wwOy6 z@E)_ggj?%n@XogkRg6_fo*kY~S!GU;j%`WAmL7#rt6S4VqwMFoK=RD(G|yVeGq2M; z7fPP_o#wen@+{~y&(|c+iJj)TSn@3FG>?qE%%V>7Tq1N9cbW(D6=Zl)r+L;(o|8Mx z^L5Fyq|-bbB+n^D^U!9Ggf5u*bOtifX1DRzx6PNbJk0$uh@{O%`W&6EpEnii-sC~H z!qNYvj(&r5We9_(49 za~?P!blx6&PU)Oh@%GsBNwM~5zdSdW8J)9U%Gn1AbLB1xl@t4wSI#~^m@D^}P&u(_dFAZ6AXn~@P&u)4 zdFAYBAXo0Ep>ksT^2*s8l(}*%L*)wl&)%WTl?(Tu*vP#4>{FAua^DZ^f$n#)n|bBz zhjY1dr-k?wTbftSez=w^_mxmNv9EdM?ALK~<$e$vNu9Y zX)j}RK!vQb!1dRL7^shu2|Gf%r4eayjwtWq#m*AucTriib5#AFNSbMhPj858d)xX^i z5Qn25ZpS{5+c!-+;8U78Yv=8-&)E;h9UeI0kvYfk&ow>p$T23S5o_nn3Y|#1R*gD0 zqRzk!WA%1-2GgspaGV#pX1Y2gOG_o}P77$1hE&3w zC9*{+x{Nifx(2jy4$Nyg5EAI@?54-Fn*hbnZldsTbBraHJIZZOxxsKKtFqrK!hE5w z1rK?(o8=QcksK|1>J4a>@a&bhYiF;FH1ydk@_k>R)ZnGjEq5~Obl=N9&>9_v&QM1( zU)Lz|K}Rmoh_55piHrMQ(I*9*v2l3Yj@m*cdL=LpDu7D+q$bD|@6SxfbuvT6Ue);EmE8u$Ri=*^AGgUf9-YaWA6#3zS zWc!njw*r!mWC!SQ3&TR+TY=U`vaAJp1~ZJMIKx92&gd|X8Ah^$08qaxXa86~E)FE^ z7TndqU)eb{SHfh;7}8l^mNg^H`m(GUVb+&r%?Pu;ENe!X^<`Nz!mKaLn(1HS?#x_U zC!%F77y*ott;Z%c++8sYSUcAP%-_U)>&$H!NBTS(h^ZUd$C(Bc&flws^ar6>!Ltk6 z7>7bfSWf`o1DeAhc4u%6XzBE= zUsk7wyP5mIdgd@Qt|z)HVBBG6N6>nRiKQ)p>lJBrYn$pg=CQugH*RGa-GsZ7@@z1s z=16uA02s|t3^NzPU^kK#;@%2ur$w@?0`dFdM}~Z0vl)|bv$5sMto!393pbA8u?%DR zSYU%$b(T!PX0qxmnLwCTXUPP@tU6035GHNfZ2soiY_frL)|X|?2(!K{Yo;7vgLAx3 zG&WdxKSZP{_Tpi!7{0xD%;<^Oi{EL)w--l>y*LqFsn;8iBl&-2FQ7nqc6V3pg*hW- ztLXoW*QEZ5F?k=Th`sPKTLV47{i9E5#MhB+K^oSiPiw^2kxil_a0|?u^c5ugI`V2z z4mAIu5ufJkK^ka2s}Y~(_k?DBK=TbG`!wG)<+x_3gwB^CFV_-pNgjQhB*%j2`inaA zczxy|B@67gbsX#Jj(p*|-Vr*P$s92GwzI=K%4`qgHn3B$u}8liev)Pepkw>w#n*Uj3w*&M{&@XP9dcg|RE{EY z*yXiu2XuD6)@55@%xyX3-}-1@d{|_8;+Ky=76psNdi(amKq>N8XI+zreU)KH{h7D+ z??4{*&4wM(apfI$xF<3m|EkAP6yr!1I(kfEtiR`vzo>l2;&$Z69kud43+|3cMb`I} zu8ryY!6TXXNeJ6;ed7h&aJea2Z??s;+4ek6IfTb8`>D8`?V;PToY8%DKTEZ_v1hNO zbFzU+ilgna*75f@?l7`(xtNi4k3LiL0~7CA@wKRvwyCGQQIGjI<4CHuObR}b-eZm; zma_Hnn8BxGpHW{2TuVlp^+^Gx?D#|n@kuM5dO85~e+XW1dpkC$Y3TLs?XtGZ_tQ+vlv~K9T00Nt0R*zlS z-PHRnwC^$SrprP0J^@=jaw-<6hi?;$mbJH8Iw-p{{%wn%BVn&1HUIEQwH$VIqwot& zl5O2PAjGy^WPlD+wc4l!rXy1jp`OM`pG&Agb7Bw$C zfAc71f(|$}f6tR^{1(vsDrlOsocb0)W9z~u!ato!+m6jeeHPVzrf%DU%Rp4-e1FbN zs8dkpr-&AnN=0{cLx(tN?3lp;b)u!|h`EH8PiGTblEEcH_6hu-kt~dB3YY2Oj>&@i z^vud=YHl~5_AsV~pzfSa_JTW}?N}C*#l57_5pBC=_oLrcg{25 z!9Ian3gc{K-9_#9Ik-2TJMN z;0%lUB~rSthxaE}9`N^c%o59ZSA7aEE8^~hI$W8D*fsgFwGu1uF`s@dlfZClHCAB} zyl>9}I_bV3>D_SBXF<}R!%3}o50d^KPI@s&`bRh^?)i0n5Kh`ZNcxaTTIgDaxNOOA_|I_CEkV*p zNWw%QbMWy-7xnmaTN1AQa9-SC>>|^}hxNu7T*Yn^e9*4~wM>UEQ!TVs{(W-4Mj>67 zz>;*dY$uf_d50#phE`E4bj|nrHS>b$bS!jz=7C_ArZOE5onZ*L%3VDT8AR0ikO7oW zY$)uw%e@9ZKjP~r#Ibj(aeSbLI6gn4ap4PBsIH<`YS!RyYg<%CD%Nu)5)ssq$4sOl zsH>kk<<2wwC-~t|`2Qz0{GwalN0$ zMV>;@lWU(NMemQojfu&0;TI3%TUODwYKE{FDf0MD{Dirvi}SUykvpx9W|Ed!6MoPq zT#^o7VEcXSdxV@ienaSl{Q5e#$+*KA)zRAP>Ne-93mZl}NDWtq_NCM%sIR~-$986y z)6u{(b3)OzKjhagmO0*$Wln@FbHG{9$@DoUc-rTv%lA26<3yJ8Icyi=i(roX7%b&^ z7Xu^y%=k$-X#pNErP4w7(0IiC$D>a(#UoU~Vv^hG%7lpqNX zc0R#7f+TDn5G0j`lQslNW#Ob>2TAF0(w~B) z@^Dfz>9bK0PC6h+sthOL%WuYcs|qLmGDyP0GbD{532V>%q%kRCW2EcGD2(+Jk+tf+cxiwESjszHR`0SyOteXfZU6-}x=bEh6c6!iMdP z7cP5O(Y|Ox@Knr7H$0U*;7^l2GoW2Pv`oJ7@(4<$Q+jdO$sBDqX!Iiv{du)?QZEz9t!8|2;cox*mel^Dme2m?ULU>TdC{L_ZwvMLS>eLNZ4;E z%0pDX!^8asc<@l1RHQUorkkjDIk?5Jiso0>hILQg&VpVO=e$R~j{r@RJq)v+*Si)% zK$F(Qgfz{!CjD6Fq&Zgi2i@_=7R8V&>}E1n*Q{MWY`gh>ccWMhD@VrxWy-ZUn8z zLCf%n7pk#greDEsL!dWS+o6QF)@cfqf$i7un+$~;G3SqF7RDM+`{+OkoQw)cv#TpE`fAM z?yFR-KUZUlhUBca`Equ)!4}Y)39+lEp^(W7ob1n3W>MzF)SAZk%Q#Fw`YNsvV?Yk~W7~`V^E!Xn~p9^%-c5Jv6UAC^G|EjCp;#Zk-EI^ZU2leh5q?-H5 zGuUMfzBxdo1m9xdZy6Rz{H>1Q_Hqf}L$t;AjgwmnZ%zk;_<%s(y|An3L2Ksz;4_B- zQyn$ma4@fw@w0E>GpXQ9s6Qejo+EehTU1dwFQ-3nN$yubTk-YWVm$=jBIffV^5hAh z!(Bx;Ui0^?&mTW70S2pM{KQer`Y=@tAErVK4^zFFkVDStxc+>(`8-v!{RQ9EiO6hQ z$&FR&B4NQ>e5K>k#YIR3}8gt3+<>x zL#h*%^0|UHle#nTEp=&)?u{fqP#lc3sP2xa*0XYTkddK2ZHe!h$Y-|lWXR8KL59%| zWXOwEU&9kecx0(UA(mCgZ4XTglp`izpk{6{5|vLFLv;G%;CZ4;B05>H6%Q|-Tk+`< z`7sjZI#NsYg^naDU-0TkqHLHi(bBF+w0dZ{Ituc95!D%gQk&kAB4RD2Sj!;Rq^M>h znNv;qT!AlEy5rTlJFBDk_K7HGJY9w_T1(@!MD;g=DA)Y!sEu4P1&Dn9UBO1TRl>LC zDm*OM7}PXDb=9gG7ey5DCYzz2rgfsQXkK-)GAZH(V~4QgN-Lvz8XL`NY)oscJX0=J zqaojy{?lV#5B(@Cy^(IJI*}Xt`4ZJF@50a*2|*RBw9vRep@sHxpp7A+$@qr2;>E-z z#@3AQM1eN?JErMm7X(>7G_58YIsRwIeSsiLeKpnF(7EBCFVwCN|BzIpE>Ag;{- zFLL5JHi#J(fil;3XKtfSfFnH_eg_litF|D$mVKe$Gb*?{(>}9-Ep@r8j(b)8QEooz zX_LgN^<9j%a{=zDiVx!0NBi^#X2cw8cSV=OZR?biH6$YMc zu~uNEiIahzMD$oxGjnm78;?Y*BAFvmvN2LOI2P%#!@-B{tD})Rc_avjIFdZ65{^xK zACzEwsHfq+ev9=(PiI?wJr;R&U+?I4F&dZt-}U*|zD%FLo!>vE&(G|z&);Ew_BjqC z`+Yvg>T{lTdN-eD4P2&icE=C1I(|0fo9lfm;W%o<0$U>jr?I(a|80W%5lq0%Z zeSk8xB{)`u^F%JH&^zK)3fn^?DKkB<$5b!m{m|r%v{!07^LMU)@q9%37l&O# z(|FLopN7jt+vifCYH4Aie1A>f7x`JPy!cm^IAs->xtSm;0W9Z*0pWi0! zQ-48TplcTu*R@-V=~`z#wQ>SolRhs8@ulY%wuU}9MkxktetvdGk?i7Ur9eiHDb2gX zvfv#@WP))5BkZpSHWlMN&q?+TAY2W7onStd!@wH=g& zaKtCTS@|nShJ8!kF|vZQ=Xo#O*+=E^;J~_081?V^eZoc;ik|Pk1`N><)6R2!g{dI_ zUQC;pU_&>z4c}oo`(2@3DQ6$#FIsMA?->+*OQ_&b!z45{e+OFY1?Q~@`!>^nUW1i~ z&h1Va<-hhJI)VAf?^m3C&fN(VHM)93AlqHL%O{5Nd_Hv_lsf#LL-D(O?xp&J)1&Rj zPNFNE^S=@FslR-*Z}5TnDRSTG7?g{HkB;vcwG{(q*`i@xCoDYdoR+ODozsH;usK22* z0d|R3TWG=QpWMjSdoGh9Z%hmw@oEb(pb@@P&pb2E<27H#F@AqtrKtBfiw;*lxT`St z@}aG72T|W(s#2vKC%YrR_^$1p!$G$sBy0PQ5L@$dR6`HF%@^YA2Kcl~ zJE3h0xI@}df^bLrw97i7Z416b+UFLd9ao1zCTSz`U6&3d#Wb^I#wYJijy>Y{l*DZ;+FA zc2-e43)eDamx|k2+7=oo+9uk@)hM^Cc9t~4c9yojk}}D&jkbp8Z2grX9;#5TV;*cx z&e>x(KcE8gw>}1??t>G?|J*5 zzhm_U`=9m;bsiWs-&gY2$5=G^>nB#H*T-dM{nUg8ha3TaecUZvF4~UmNiKZ~3l;On zYE4@nGrHWwyEPvtLOs#%WcqoYu=6~bp9j9CjESdA9_ko<&75E7&zZJ8rIT53)rZ*6 zeNi@oRIIpv4|(R^6*l9<)~>q)DtX89K&J!W(pIaYzFtDcN74GR(`Q()RjCeQEZjUt z8#?5{wsb{#$h*f7?nmK!;I>fDKDW#fgGrwm{uon0I^XC}Ld6oJ+p88zkzdg$1rACwNA(60@Iscex$GT(> zhN8Np-yO!Sy7_A?dmLQGdQXJu@ZTNQ-^1vs?E|*X{z!4e;+ciWgAZi%!B1g(UuJu; z-rTC&9Z?NvH_TXmy>@%aFRJ7?DVjIjw$Ad}?b#V!d-Mi*@%{z)?S(d@WA%9{a{{W= ze^J_cN!lL5LARNAq-(1q&Aq(J$ObI7T|Cm!r=IFDBUMK5EHhHciw_1Zbio8|WvH2_^;P3%fYZo-=pTXCb1C%2v275i23j_rz(oBa|zQ12`@vTq=#+nU$Cx}mALl7O zS}r`)T7jQT0}Piu%)&PE@Ylq^l;M~Y({MIa`~CV*4$g#PzuWWIGxhc-8|qP+cuD$1 zs6O@~=R)Jf&V{nBH}M*zRM*LgQ0~KXd^E5vdVJLDr+#wpjelE1Bs@IyYZbnp+H0o1 zKBK&-!5SYOeWNNop%wFKOZgoi)en@VJt+_47O#V(Bh^v777|Oxs^jT6jyZ`iIm_T> z4+yg|wgqSLa9qyvbnH2?zs0IPIfoN9JP_ue2u2Ii3Hvxq!a5D(9~H+KEK^tJ@yAzp zz#IihxSZ7per0EcgkUBHYPlo7n6U7W5u4vI~Xf*xqHx_n~l;> zuD2)V`wK0jKQD*(-RybUzJ;m7dAZ2On?J9HXE|ZRB{%_`ujhnT^+r)4ulYEaZ zl6hScgS>y$dHMYl$&h(fBJ8z1Li2pp_xq}99EKY=GjfWhfMh_`>InqllDS-6Rl8Y%wJYUeQZ#Nt+GK$@RADjLV>OH<(p! z;2Nom(~+n)r|D>PJv)_l71PC(baYClJIzt}PVwDv7Rhq$a5{-G!esDW2i)<-d%^qQ zCtIh(^$d5{;Rc3#=x|?#d+KmMhI{F7e}-{4YQdf2q|H0R`I~n~IN5+Uv%V~AMwsE?V%Wo{Z2Y#ERFFVOEM^$tY1Xu5GO7VQ@iv2*K$X)%6mhXZb zP&}Q{l0Lq8I-}`JdGhVs!5H1{ibD`Lu(hJm?Xw=%+ZmY3GDh2Qoo|TbJ3N;U6O)U4 zjPdh*7jhoTeBO#95S?XB-pVO}E875g|81YlDNrk+j)x)0IF%VE03duM!-wkdQ4CMi z;b{yXro%@wJV}SAGd!8$%pNc{wHwG&iMJAG!Xqn>0Vs{@3wIOxr%&coRL%o>*lK}N zPzJXco}n*fH%rFzc+Lz5X2V>w6L zAIm~JXWNz=n*-u8FU$vH^7;5e*MW-!BUuH2VhM&F9mcz+k*ur3DTX~AE@3#L!=(&I z0m9!LB5m3{{^r>{vH{&;eOcCwFzd^*W`tQ^mNg^H`m(GUVb+&r%?Pu;ENh1P(8lH3 z>dQsis^yYz8?e04wxPRk8yMq{`Cg!>Z3vbh$XD6u)>rr$8HJ4b^ePJIF~+CYGoV*h zkdHBbzFfW4k}t1bMitasQ$UX~KD}JMwFUVYSa_xz3_uV@?(roFIR7m zf_#ke^SzD%GECdnfr!px@dvYq+q_`*XtGn@%0@)390O2d?in}Mue)#d;J~Ha%%MS< zQg7w%EVCa#nX!>cZ7S<4{6f6^)y+%{3RS~&WmpO~W?~x)8&-1rEOxErH>gbSMPYml zLcVMzfSWliMhvnW80O)*+~BPEM`Jm+c1NW)9C$f!GF<%0Z-3R#|GOl!dAAh8BqK zh+N6Ew{i$ej$_I4%Csq2u77hfuP#T?w40fdD_Y^L#B3E=iIXsq>dMLrQ?xQ%Db5&F zSKuY3T*)eLF-o zrTjb7cd$-X&r<1a4Tsn)<=>gU+ZqlHwv>OT`fh7DRM=Afo$0%+;W#E{DgVy&9gU`{ zXQ}iEQ`NIndW5O!St>okRP`*C9$~6_mP(H>RXt0kN0_RfrP3ozRnJoC5vHnVsq_d_ z)w5K3gsJLTDt!}eJiooQG3Se*2_c_|G5Nm8A&9})Iubuw3@x(px9 zFsv`b(;0?JF+77|=m^7Y45OzRK89iR9m6vjMrUY$Wxe4M4PgEBSNNOfuaH%wlcy}X zLzp~e$sNMvDNF7UCQn&%hcJ1{k~@USQX_p8U;|Cs{*#Sqanmo0m?0kj{#;WC3AToFxkgv*IjSK$sP0$pU5eS9e8D z4!+Dp4wRW|wcJmXmWx2Cuj6v^JP9Q8<;j?QAuU7<)9mvN*yllx1-=1paKUexFsTU-v!MOQ#@bk@XUzWxdi~Je|>!zM^0>mv_2+7KVfW?2EkB%5UgnjB`0ToqlSP2M5n>p-G?iGFk;&pq%w zB$Z{XPQMYMB7MMU&EGoc)1JERn-H1(HUQfGJ%+E>;oBI#L5IK3@OO0hc7{m_`R`!( zCLR6(!#C^j4;j8ihwo(gy8zzG9|5lXF#z``YU>-?Pbb^AB7%aW+;DE0_XSl#R%9tl z<`5=JSu%$(S;~?*gvnBt%ppvcvSbcnvXmur2$Q8OnM0T?Wyu`EWGPGL+!f@YG_hr1 z3tsvIM{VfsfYlP?C+n|0>Adm1SL@_3y8|B+yW()B%Y`B26HNfkC%LC;iq-@PYiEi zc;z#IJGz|%HZ=>{>`jF1TCkl>rgWYRo*Fhcx-0)+=DDDlkw7PDc`TBjU% z)WicFyeP>(D62YS_~4;~_Zm8KI9`HKDk|@%FTV!k9>?(C#_vY#-S$6f`RR*KT?mVW z?P|Q}bWsX%M<1mUI3UkQ;r$Oe`cV1>-GSeL177_PT(Wd7Gh2V$>zncNP01wAld4ah zJ@{fJxi}pEpTmD}r!K_*`=d&}BXJQDe~ftMnTG$v@E^8E-qAi2VeUJ_f=D`w$T@C2 zxmQq5#b2hdEKf6@i#O9#C~*hEzd$&Kx6~Qa?A!r(nR9~^Q_nbz`3NyFRpB;+&Y_Xf zh&d<1JU;@Ash>qy_Hn?JdNuM+B&K%94O%I6T=WJftsads|2{G1e_7z<_@a1PjZch5 zsp*Mkyt_R+aVRL?g_xAunqbaBNy4#!Y4vfEIcrm-|AT7AZvl*{B{eP4n3~sv@jvf* z2Sm4dw>H360b^>fe$5EaZ)`(q>+a0ogbPaWg<*lG3OoZarB-F`01ul79g1*!6X~DX z%=~o|TB5&IR}P@`c1$1-nM0ZX*E5)BRNJC>N}UIoR)@`E>NB%iqP6Pd%SExm<#>xeI6j%j9HG)Mw zoz_FJGh^LBCy6g^B{2a$3T!H{eI)G?(2PPt`(m!DP|K=$-npClx;hWovo#vKTG9@K zZkK`1cLf_(N30LNXv%V4$-ob`t=*xIHZY*BwzE?C`e8mkd(46rt&)d_YuumQk&3-)VZq|z!_ zbA5Mk-5>Y;k><3%-PIys%LKc?V9N!&!C+?zR@+bKJXf&Cfsx7;4(0jJ{*-5bb+c0j zjQTbet-n>$?is+eVQQ05m zX32S9BdHvq9uh3IyT+an>}i9&D_FOTPTMZnBfz34mvVusxlP^ijfVqNZ^25Mi5+dQ zwSt{su%`uEVz510nDZ=yoh#UCgGE}IcB#Qe2zI%_ju7lBgDn#58iU;+*bN3t4kndN z2J0`_j}7(-H2K%+=LYlQ#O^oPt&(%I!Tu%KqXugo!kqtSu(5(YW3UB+J!`N#1>0t@ z2L*f0U=2e_%J$`1{-X` zUc@FCY=K~h8SI~eO*2^e2 z!HzhT7Nyo*BG_Dmohg`8t!b_ltf#?N36?h4xq{t>a;$xgU=JH?tzcV#l_KpD!JY?p zms9I*5X^z(qe%OPU=BxQwg}jF1*<+xW8W9-QDDsZW5GTKwh=Y_ zO0d#Nn&tz79Wz;D&j@yj!Cug5Q*~O>qpj;djh3j^t@m=aZZ~(Jr2RtD2Dpt@+8}q3 zr0sh&%MEs$1UpZ#J>3?;z9HDY275)Y{S5ZZbe0?M4z*|=;g0Z9;AKi1Ep3}SQm|_U zI|dl}{7oCn%>+LW7MEY$-72oGsYdCT*o)D@@uq1UnyCC34;_ z*oDBVfR*83$y9Y2Fmg6ku&WH#F4#tcT_f0a2D@FbZyW4E!EQ9z9|XJEVDAX_U4!+T z&H8QyMqUn{%@%zRSdN#Un4FrIpBqf`a<{=WFTXUHuHjb()13XH7W%jJ^3?so^<;H6O>;zG|@1g1v6A zuM763dytfSU@zwUtHF*xp4fJStrYC<2HPgshrn`r{i!=nsI<;uxi8#pPz`4>H&o z!NwVEj$j8HY>i;!fl-1t&u1GB0hVjuRBwiE-vXx1^4hGl6TF#{He1pbdb6ywlf2oI zcAli2;vFa0*b_;m-J2uWX@afr=33=ed5c9~RxV`Di@cLWF1Igai>?4hK3|cvjRre$ z5p#aqTVhe!nNbN&#QgN#K*jp*(4n3JvJ~7xGf_>(l>rG#s z_Nv|KtLp`h6gXAj$pTjkyi(w8fHCz}jPM_^8?g%eBz7yH7rz~_D*mI0qgvy?1-vN! z6ySH`&j3Cce-7}q_)CCJVjJLYiPt03SO2+&^`^QJ_7^z2mf^DmZWOpl;AVlZ13K#7 zo||!b!ZSS?{P?~f`ashBbRg+R8X2x>B!&KstbLS(j}XY5G07Q|oUtG$ z-(@B6A2wW%da)H+iyj9?j1^z z0zVe0nosHxL%o!CkLD{;Z-coC|uvP8D+O72)8v8zANx=0xxkG^QnZL7KYOTYXuGf z^f|e{=~<-i-$Hn>z{3R26nLV*Wq`f}*0sEZoR@Ti`rEKmMz&{SbdC`U@p(@l1g|_E8#kUj|hBD;9miA`9~nnnK8oiS_$tFxK7|B0-qE3SAkan`emwO^h<{Yz(*m~&d|zN&>yLt*Hx51+t+-BLbO^)c0(%4c)J6=Mi1@bFi9yVaA=3~u z8_>_QY{)T)IYZzIf#(XmMBwEDuM_w^K)=*o>Nu3TZ^&^$%risgA?7Yc_`HN)5%>>* z(V>hl6<7uze{EEOVAoIwG9(E=2d`sX>0yhb~Z^)GaoqLB}hdjR%__V;61imS7 zJD^{qGyFTqSs`$s!2JbI6S!F5`2w#N_&tF?75Id}zX+_{gLH-pJVM}dftL%sL*Rpe ze!ZIqy^8!V?D1+4^T8f(A?6c-YEOn^0?PpXQfJ2ALww_&gkuFBBk;Ud#;g-~mB6P5 zGiHgTo+VACd4M1imeByTHg^q}f|wi@<#Vecop7)xQ@t zxqmM|X6arT#C%2IIRd{X@LGXC5cq(==K%du&WKi_(;CF|8ZjI({RQqR@DPDB1fC@D zVu7~_d|2Q+0^=iDwoYJ+z|jJy3OqsJ83HdAcr&2S$pa%dmrY;&h`^@=J`3ol{(a3Np`vUJ4_?WVhrnq9 z=L&2Wcp;$A)%W&YjGT80{H4IQ*2O{U^;< zg_zR>o-6Ph0S1>w<|cvP61Yj=gwc#|YrQMTId}9g5Oboy zlLVeB@N|J^3S0r`Q~uiMdy)TYfo-k#2Jt^1{UG9hEAWp3-xc@)pkKCT%0=wuDE^vv!D+T^U;5LEoLCo1A@Gyak z1+EgfQQ%JmJ}U4vfgcJi8OO32f#U@(6nK%q+W=!~=rnrHW2VuI{y2GkOH3Um;VA;= zPJ`E^PLuG^Y0TfXoH?40Pg~d{rd|^GXMr}I!qkI~CMS~w9xZT|z_~}i0p3m)IJ}v8 zW(u6$%J6;??jdlV#QgYZ%RqH_tuf;x#MI2d46Ygk9?F?o4U_PJ0^4R>3TjJce1@DXh38pqhqZR4R7?$Q zy9YU!wXxK)HgYn8-l;kQzNn{OmiT`PRL4*b<$#_Va143dTi`^2a{yy%`%L!K=QA00 zXAx>i_LFdnK;75HSCM{xE&0Myht29cxT6(lOr0`|wYOXKYC1E9kP}U<^V)3+-?6y; z{j5gRduFT|@VwTcfcLcS1-PztU%*FN_XpfQYaHO`vknEks`YTdrw1Pe*!x)4K1kq5 zf#U?u6R5ee!xu}umX#fEhr5y|KAZL0Id$8AKMP(x+R_Hz&TE|wcu(tGz;&$)0Uv2y z0=RwFX@H;4Is@>k))jyqwc-S+MMJwT9iw?DOfAfLlF<38K%Y;nT)^RK)P7Iv1%T^X zF9v+1bpzn`SyuplKI>}0&Uq-Ty-+fr4ujvQ?wt)kQ2kcmQv#o#O`U&TxccX8c>XGR z9QP2q9mn_vfrFCptkh9c;Z3O-$9;RSr%pJIlD`dMJo^^-dx0+r{Hwq(1Xdi+JPiVe z3p_;N^*!Musnd@qolB2r`1=yxd^|^}-s>2Y{0_>N%we9NMF@|Y`d!56{f&-NZL2#$ z%1)j06O=k(&fS0)%pv`Y1=`lK^PIQNc?hk(ZO%uq3_lb22q0{)#Q#ZR{w#2Z#8;lc z{52;qe}lk11da!U43QdB3k0?cyinjb1%6-P-2yiY+#>J|f$s|>Kd``a%ZJ3&qjS#& ze0lC`faE8p-k>;pG;63wc55HVltz(BQVC_dug|}&T z%%%wCU+&9#wWb}ifVFg-hZN3|QhLu#m&(O>>IzA{N#M@~{-3}%1bzX?d5|^kd>-VC zb|q#mJ$qhsBFo-zVk_jPXGX@rsti5`FHn{)Be<$&P<7Iw!(yslAn8C>Uy9Duli03l0>?~c_&5n4BH^z}_(DKWT`l1kPm*~= z;L|M(|3$(d0>U#q=_GKKIGOPk0z1neQ;jFD4&`6g_69B~n0N9!cy;aMlet6wfP{Z9 z;Vpnu8hCzZZTCx5HO{XbtFgqjxSP>c%LQAbwyOPr-LKPdLS-?eo#=~VYOOldSp#WJ zGFZEF4bJFXXRybdXL0^(Q-Hk#Y`ex1ecjLSBzb5*p(3^8`+yo#d$|kn4ER`sjS_67 zU~AN4PPtR2?l;&Z_ai(j*{*Yf$}~KUY3T3Mob6PpDFIfEQ%1*XEV0o&#p$M&3${jW za?b{KcaZaEPOW-7z<7SC`v9M2HQw4Dps~cW?vqY0HCnJW>TUN$V5_a1z12FC^8s%! zcQq}?sp8nwe4@Agse8LT2Q%B@$W16lhTwO8aL)u2WTc9l9I za)R5SCK&9h$Xd6bS{Y#1x&zdm2K!~?L3ekh8cF3U^~=Z~-9c)S!Tu5Xo7Wo9U9QH(vfhDek}iiHd(<1J&JVB`z42;WfPLs4s;1!Zr`FG!$PsFr#?<#?gCf(_ zdjU2!GD8g=!m?8z)9}?QcissZ4;qADOTA46qL)3)F-F`y#SX9jh@lFHw$1eoF*9S6!ay9z9uY z6znQ>Lt;SmRJAFD!-GW_?v_qq3sh0#>tKLYgimp<3Hw!PSB)L9%j(W*pvy$J5 zu2zW_ot8~*ik_=#40dty&gdGor@`JxZjN4}#u;oz>ec9_YGr`^IeNLeS!0O{QXfUX zsczSpjLmPVy9L{wV?(mqI4$F5OJOj@L*JFv4%T1`ox*tKf4N!z`oKd^NsZQqhXvFp?oChf42!N6`X zX~&lA8T*#nWYSJ9*$3ENChe;w`^Ubmer3`wDH#XscP8z+l8LeF)l&w$tK=hfy?V}I z50{K`uUD^YOg&f97P~P28`6tyngVD}Et)4O%?ff6q0Gu!8=wF;(pq^FZ47Oab`GT!c zUro=7KdZJI?1pqU{(@S$r>^hU>95CMRtda5&Dvi`UmxG5t}xg~=?CJksTN){gtW%; z*W+)h%?3N9Jf3(*9V@4#*Qn#l$0XiU4SVaHTgs;;{-!Q6SfXN1;sdqaU_&Y{NqnT9 zf!QL>H5K1V{7a4AS7SF<{1}H+?=;vSDt?=AotjZPt+sMYBI2B7u&I^X5;5l`gRQCj zOCsTn9<6iUQu#?Dd5hbp7VQs;BQ)~df$_D!ap(YTb7GE-GUlI6}ygEdu+PF6a1 z8SH?n1;8@6>bG z?m9r1yS3(w)NrTbK#l#Z=DgHi&N#u&m)b`-Q%u@H-EK*Zbe0+H*lzcx_HiyX*rIOF zrA9e-8tm)cUP+B{o-x=jyS<&--}%^JuXNj2FV3TFrwb$cRpP=FoV?XJ}L06VDL zb*V!Q_HgtGKSa(W0&E3x9_jQxh&0!#FKWA$9PO+&SdY4vD_Nfqi$l!EN9%on#w_S$Cn)EObf83CC59f18h~v9OnjuO{@D_$z11d zgRQLFSTf&v%3xpAUSG1nc`3kdEjiJ7JHUQWve5ZB!0s+t>~tS5wI{aJJyLSAGumLU z)ja`hk-`2^_mNuStTR}=`zUvbbGN~Ib$_Ph6z3U(HFbX;m^wt$+^73T>QrZd!Hzh2$xoaVGl&{Ddud%ASFv&dl2b+0Qu z)44&gHR_UI)r*xvGGO5Sx(sP}?18hF9X$Cu` z$MVwioYeug0@!s1yQ0U%rE8qc0k)#_eCH{H-P2=!=>^V90k*MptrIy+>XQ~-=u~Jd z@l=mnN-uIU2795$_kryx*c$aZu&+5w40cbChe|JY?l)Mx=X0g&oSI3xeS>my3whb!n6lnj;dRnje_Yl!Y1ct z!5&tu;d@T+shY~no|DRMccuuY>$}7Gox#ZGozB=JHBHv=6KAtvYf<}AWj}K&j>^^d zbLR?!kavtTVx+E$ubReb$*~(k|-teA#o( zu_o;sy*8=moJA(>8l*k%EHi00Bkg%-rAgc9K412NbG}LY0n%P@F4bvh!vgi9voXNl zD|^wo%anV)*Wb%ta(-p74|{zK>~}%VYW1@7j7f|2{zz?gUNTs}-lN>D&f5mtuXiN< zCkO7gw0%ugs|hLXSHCguOG0xgPd`+sn(`ivsL7<<;&+!MF-}w!DXX zzhHXwH@J^!EHQ7l_sjdb&j_|gE#ECx(brva9C=xzzP?-EiUIC6gWZ6fjc KA-b& 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 I|9=$tA08Mu$N&HU literal 0 HcmV?d00001 diff --git a/Libs/SharpDX.Direct3D10.xml b/Libs/SharpDX.Direct3D10.xml new file mode 100644 index 0000000..d8df4ce --- /dev/null +++ b/Libs/SharpDX.Direct3D10.xml @@ -0,0 +1,13207 @@ + + + + SharpDX.Direct3D10 + + + +

+ This interface encapsulates methods for retrieving data from the GPU asynchronously. + + ID3D10Asynchronous + + + + A device-child interface accesses data used by a device. + + ID3D10DeviceChild + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a reference to the device that created this interface. + + + Any returned interfaces will have their reference count incremented by one, so be sure to call ::release() on the returned reference(s) before they are freed or else you will have a memory leak. + + Address of a reference to a device (see ). + void ID3D10DeviceChild::GetDevice([Out] ID3D10Device** ppDevice) + + + + Get application-defined data from a device child. + + + The data stored in the device child is set with . + + Guid associated with the data. + Size of the data. + Pointer to the data stored with the device child. If pData is NULL, DataSize must also be 0, and any data previously associated with the guid will be destroyed. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10DeviceChild::GetPrivateData([In] GUID* guid,[InOut] int* pDataSize,[Out, Buffer, Optional] void* pData) + + + + Set application-defined data to a device child and associate that data with an application-defined guid. + + + The data stored in the device child with this method can be retrieved with . + + Guid associated with the data. + Size of the data. + Pointer to the data to be stored with this device child. If pData is NULL, DataSize must also be 0, and any data previously associated with the specified guid will be destroyed. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10DeviceChild::SetPrivateData([In] GUID* guid,[In] int DataSize,[In, Buffer, Optional] const void* pData) + + + + Associate an -derived interface with this device child and associate that interface with an application-defined guid. + + + When this method is called ::addref() will be called on the -derived interface, and when the device child is detroyed ::release() will be called on the IUnknown-derived interface. + + Guid associated with the interface. + Pointer to an -derived interface to be associated with the device child. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10DeviceChild::SetPrivateDataInterface([In] GUID* guid,[In, Optional] const IUnknown* pData) + + + + Get a reference to the device that created this interface. + + + Any returned interfaces will have their reference count incremented by one, so be sure to call ::release() on the returned reference(s) before they are freed or else you will have a memory leak. + + void ID3D10DeviceChild::GetDevice([Out] ID3D10Device** ppDevice) + + + + Get data from the GPU asynchronously. + + + GetData retrieves the data collected between calls to and . Certain queries only require a call to ID3D10Asynchronous::End in which case the data returned by GetData is accurate up to the last call to ID3D10Asynchronous::End (See ). If DataSize is 0, GetData is only used to check status where a return value of S_OK indicates that data is available to give to an application, and a return value of S_FALSE indicates data is not yet available. It is invalid to invoke this function on a predicate created with the flag D3D10_QUERY_MISCFLAG_PREDICATEHINT. If the asynchronous interface that calls this function is , then the following table applies. Query TypeOutput Data TypeSupports Begin Method EVENTBOOLNO OCCLUSIONUINT64YES TIMESTAMPUINT64NO TIMESTAMP_DISJOINTQUERYDATA_TIMESTAMP_DISJOINTYES PIPELINE_STATISTICSQUERYDATA_PIPELINE_STATISTICSYES OCCLUSION_PREDICATEBOOLYES SO_STATISTICSQUERYDATA_SO_STATISTICSYES SO_OVERFLOW_PREDICATEBOOLYES ? If the asynchronous interface that calls this API is , then the following applies. Counter TypeOutput Data TypeUnits GPU_IDLEFLOAT32fraction of time VERTEX_PROCESSINGFLOAT32fraction of time GEOMETRY_PROCESSINGFLOAT32fraction of time PIXEL_PROCESSINGFLOAT32fraction of time OTHER_GPU_PROCESSINGFLOAT32fraction of time HOST_ADAPTER_BANDWIDTH_UTILIZATIONFLOAT32fraction of theoretical maximum LOCAL_VIDMEM_BANDWIDTH_UTILIZATIONFLOAT32fraction of theoretical maximum VERTEX_THROUGHPUT_UTILIZATIONFLOAT32fraction of theoretical maximum TRISETUP_THROUGHPUT_UTILIZATIONFLOAT32fraction of theoretical maximum FILLRATE_THROUGHPUT_UTILIZATIONFLOAT32fraction of theoretical maximum VERTEXSHADER_MEMORY_LIMITEDFLOAT32fraction of time VERTEXSHADER_COMPUTATION_LIMITEDFLOAT32fraction of time GEOMETRYSHADER_MEMORY_LIMITEDFLOAT32fraction of time GEOMETRYSHADER_COMPUTATION_LIMITEDFLOAT32fraction of time PIXELSHADER_MEMORY_LIMITEDFLOAT32fraction of time PIXELSHADER_COMPUTATION_LIMITEDFLOAT32fraction of time POST_TRANSFORM_CACHE_HIT_RATEFLOAT32fraction TEXTURE_CACHE_HIT_RATEFLOAT32fraction ? The value returned by a GPU_IDLE, VERTEX_PROCESSING, GEOMETRY_PROCESSING, PIXEL_PROCESSING, or OTHER_GPU_PROCESSING counter may be different depending on the number of parallel counters that exist on a video card, and those values can be interpreted with the following equation: ? Equation to interpret the number of parallel counters ? The number of parallel counters that a video card has is available from NumDetectableParallelUnits in , and it can be retrieved by calling . + + If this function succeeds, returns a containing the asynchronous data sent from the GPU. + HRESULT ID3D10Asynchronous::GetData([Out, Buffer, Optional] void* pData,[In] int DataSize,[In] int GetDataFlags) + + + + Get data from the GPU asynchronously. + + + GetData retrieves the data collected between calls to and . Certain queries only require a call to ID3D10Asynchronous::End in which case the data returned by GetData is accurate up to the last call to ID3D10Asynchronous::End (See ). If DataSize is 0, GetData is only used to check status where a return value of S_OK indicates that data is available to give to an application, and a return value of S_FALSE indicates data is not yet available. It is invalid to invoke this function on a predicate created with the flag D3D10_QUERY_MISCFLAG_PREDICATEHINT. If the asynchronous interface that calls this function is , then the following table applies. Query TypeOutput Data TypeSupports Begin Method EVENTBOOLNO OCCLUSIONUINT64YES TIMESTAMPUINT64NO TIMESTAMP_DISJOINTQUERYDATA_TIMESTAMP_DISJOINTYES PIPELINE_STATISTICSQUERYDATA_PIPELINE_STATISTICSYES OCCLUSION_PREDICATEBOOLYES SO_STATISTICSQUERYDATA_SO_STATISTICSYES SO_OVERFLOW_PREDICATEBOOLYES ? If the asynchronous interface that calls this API is , then the following applies. Counter TypeOutput Data TypeUnits GPU_IDLEFLOAT32fraction of time VERTEX_PROCESSINGFLOAT32fraction of time GEOMETRY_PROCESSINGFLOAT32fraction of time PIXEL_PROCESSINGFLOAT32fraction of time OTHER_GPU_PROCESSINGFLOAT32fraction of time HOST_ADAPTER_BANDWIDTH_UTILIZATIONFLOAT32fraction of theoretical maximum LOCAL_VIDMEM_BANDWIDTH_UTILIZATIONFLOAT32fraction of theoretical maximum VERTEX_THROUGHPUT_UTILIZATIONFLOAT32fraction of theoretical maximum TRISETUP_THROUGHPUT_UTILIZATIONFLOAT32fraction of theoretical maximum FILLRATE_THROUGHPUT_UTILIZATIONFLOAT32fraction of theoretical maximum VERTEXSHADER_MEMORY_LIMITEDFLOAT32fraction of time VERTEXSHADER_COMPUTATION_LIMITEDFLOAT32fraction of time GEOMETRYSHADER_MEMORY_LIMITEDFLOAT32fraction of time GEOMETRYSHADER_COMPUTATION_LIMITEDFLOAT32fraction of time PIXELSHADER_MEMORY_LIMITEDFLOAT32fraction of time PIXELSHADER_COMPUTATION_LIMITEDFLOAT32fraction of time POST_TRANSFORM_CACHE_HIT_RATEFLOAT32fraction TEXTURE_CACHE_HIT_RATEFLOAT32fraction ? The value returned by a GPU_IDLE, VERTEX_PROCESSING, GEOMETRY_PROCESSING, PIXEL_PROCESSING, or OTHER_GPU_PROCESSING counter may be different depending on the number of parallel counters that exist on a video card, and those values can be interpreted with the following equation: ? Equation to interpret the number of parallel counters ? The number of parallel counters that a video card has is available from NumDetectableParallelUnits in , and it can be retrieved by calling . + + Optional flags. Can be 0 or any combination of the flags enumerated by . + If this function succeeds, returns a containing the asynchronous data sent from the GPU. + HRESULT ID3D10Asynchronous::GetData([Out, Buffer, Optional] void* pData,[In] int DataSize,[In] int GetDataFlags) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Starts the collection of GPU data. + + + Calling Begin starts the asynchronous collection of GPU data. Calling causes data collection to stop. See for additional information. + + void ID3D10Asynchronous::Begin() + + + + Ends the collection of GPU data. + + + Calling starts the asynchronous collection of GPU data. Calling ID3D10Asynchronous::End causes data collection to stop. See for additional information. + + void ID3D10Asynchronous::End() + + + + Get data from the GPU asynchronously. + + + GetData retrieves the data collected between calls to and . Certain queries only require a call to ID3D10Asynchronous::End in which case the data returned by GetData is accurate up to the last call to ID3D10Asynchronous::End (See ). If DataSize is 0, GetData is only used to check status where a return value of S_OK indicates that data is available to give to an application, and a return value of S_FALSE indicates data is not yet available. It is invalid to invoke this function on a predicate created with the flag D3D10_QUERY_MISCFLAG_PREDICATEHINT. If the asynchronous interface that calls this function is , then the following table applies. Query TypeOutput Data TypeSupports Begin Method EVENTBOOLNO OCCLUSIONUINT64YES TIMESTAMPUINT64NO TIMESTAMP_DISJOINTQUERYDATA_TIMESTAMP_DISJOINTYES PIPELINE_STATISTICSQUERYDATA_PIPELINE_STATISTICSYES OCCLUSION_PREDICATEBOOLYES SO_STATISTICSQUERYDATA_SO_STATISTICSYES SO_OVERFLOW_PREDICATEBOOLYES ? If the asynchronous interface that calls this API is , then the following applies. Counter TypeOutput Data TypeUnits GPU_IDLEFLOAT32fraction of time VERTEX_PROCESSINGFLOAT32fraction of time GEOMETRY_PROCESSINGFLOAT32fraction of time PIXEL_PROCESSINGFLOAT32fraction of time OTHER_GPU_PROCESSINGFLOAT32fraction of time HOST_ADAPTER_BANDWIDTH_UTILIZATIONFLOAT32fraction of theoretical maximum LOCAL_VIDMEM_BANDWIDTH_UTILIZATIONFLOAT32fraction of theoretical maximum VERTEX_THROUGHPUT_UTILIZATIONFLOAT32fraction of theoretical maximum TRISETUP_THROUGHPUT_UTILIZATIONFLOAT32fraction of theoretical maximum FILLRATE_THROUGHPUT_UTILIZATIONFLOAT32fraction of theoretical maximum VERTEXSHADER_MEMORY_LIMITEDFLOAT32fraction of time VERTEXSHADER_COMPUTATION_LIMITEDFLOAT32fraction of time GEOMETRYSHADER_MEMORY_LIMITEDFLOAT32fraction of time GEOMETRYSHADER_COMPUTATION_LIMITEDFLOAT32fraction of time PIXELSHADER_MEMORY_LIMITEDFLOAT32fraction of time PIXELSHADER_COMPUTATION_LIMITEDFLOAT32fraction of time POST_TRANSFORM_CACHE_HIT_RATEFLOAT32fraction TEXTURE_CACHE_HIT_RATEFLOAT32fraction ? The value returned by a GPU_IDLE, VERTEX_PROCESSING, GEOMETRY_PROCESSING, PIXEL_PROCESSING, or OTHER_GPU_PROCESSING counter may be different depending on the number of parallel counters that exist on a video card, and those values can be interpreted with the following equation: ? Equation to interpret the number of parallel counters ? The number of parallel counters that a video card has is available from NumDetectableParallelUnits in , and it can be retrieved by calling . + + Address of memory that will receive the data. If NULL, GetData will be used only to check status. The type of data output depends on the type of asynchronous interface. See Remarks. + Size of the data to retrieve or 0. This value can be obtained with . Must be 0 when pData is NULL. + Optional flags. Can be 0 or any combination of the flags enumerated by . + If this function succeeds, it returns S_OK. Otherwise, possible return values are the following: S_FALSE DXGI_ERROR_DEVICE_REMOVED DXGI_ERROR_INVALID_CALL + HRESULT ID3D10Asynchronous::GetData([Out, Buffer, Optional] void* pData,[In] int DataSize,[In] int GetDataFlags) + + + + Get the size of the data (in bytes) that is output when calling . + + Size of the data (in bytes) that is output when calling GetData. + int ID3D10Asynchronous::GetDataSize() + + + + Gets a value indicating whether or not data is available for consumption. + + + + + This blend-state interface accesses blending state for a Direct3D 10.0 device for the {{output-merger}} stage. + + ID3D10BlendState + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the blend state. + + A reference to the blend state (see ). + void ID3D10BlendState::GetDesc([Out] D3D10_BLEND_DESC* pDesc) + + + + Get the blend state. + + void ID3D10BlendState::GetDesc([Out] D3D10_BLEND_DESC* pDesc) + + + + This blend-state interface accesses blending state for a Direct3D 10.1 device for the {{output-merger}} stage. + + ID3D10BlendState1 + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Initializes a new instance of the class. + + The native pointer. + + + + No documentation. + + No documentation. + void ID3D10BlendState1::GetDesc1([Out] D3D10_BLEND_DESC1* pDesc) + + + + No documentation. + + void ID3D10BlendState1::GetDesc1([Out] D3D10_BLEND_DESC1* pDesc) + + + + A buffer interface accesses a {{buffer resource}}, which is unstructured memory. Buffers typically store vertex or index data. + + ID3D10Buffer + + + + A resource interface provides common actions on all {{resources}}. + + ID3D10Resource + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the type of the resource. + + Pointer to the resource type (see ). + void ID3D10Resource::GetType([Out] D3D10_RESOURCE_DIMENSION* rType) + + + + Set the eviction priority of a resource. + + + Resource priorities determine which resource to evict from video memory when the system has run out of video memory. The resource will not be lost; it will be removed from video memory and placed into system memory, or possibly placed onto the hard drive. The resource will be loaded back into video memory when it is required. A resource that is set to the maximum priority, DXGI_RESOURCE_PRIORITY_MAXIMUM, is only evicted if there is no other way of resolving the incoming memory request. The Windows Display Driver Model (WDDM) tries to split an incoming memory request to its minimum size and evict lower-priority resources before evicting a resource with maximum priority. Changing the priorities of resources should be done carefully. The wrong eviction priorities could be a detriment to performance rather than an improvement. See {{QueryResourceResidency}} for additional information. This method is a wrapper for {{SetEvictionPriority}} and is provided in the interface for convenience. + + Eviction priority for the resource, which is one of the following values: DXGI_RESOURCE_PRIORITY_MINIMUM DXGI_RESOURCE_PRIORITY_LOW DXGI_RESOURCE_PRIORITY_NORMAL DXGI_RESOURCE_PRIORITY_HIGH DXGI_RESOURCE_PRIORITY_MAXIMUM + void ID3D10Resource::SetEvictionPriority([In] int EvictionPriority) + + + + Get the eviction priority of a resource. + + + This method is a wrapper for {{GetEvictionPriority}} and is provided in the interface for convenience. + + One of the following values, which specifies the eviction priority for the resource: DXGI_RESOURCE_PRIORITY_MINIMUM DXGI_RESOURCE_PRIORITY_LOW DXGI_RESOURCE_PRIORITY_NORMAL DXGI_RESOURCE_PRIORITY_HIGH DXGI_RESOURCE_PRIORITY_MAXIMUM + int ID3D10Resource::GetEvictionPriority() + + + + Gets a swap chain back buffer. + + The type of the buffer. + The swap chain to get the buffer from. + The index of the desired buffer. + The buffer interface, or null on failure. + + + + Loads a texture from an image file. + + The device used to load the texture. + Path to the file on disk. + The loaded texture object. + + + + Loads a texture from an image file. + + The device used to load the texture. + Path to the file on disk. + Specifies information used to load the texture. + The loaded texture object. + + + + Loads a texture from an image in memory. + + The device used to load the texture. + Array of memory containing the image data to load. + The loaded texture object. + + + + Loads a texture from an image in memory. + + The device used to load the texture. + Array of memory containing the image data to load. + Specifies information used to load the texture. + The loaded texture object. + + + + Loads a texture from a stream of data. + + The device used to load the texture. + A stream containing the image data to load. + Size of the image to load. + The loaded texture object. + + + + Loads a texture from a stream of data. + + The device used to load the texture. + A stream containing the image data to load. + Size of the image to load. + Specifies information used to load the texture. + The loaded texture object. + + + + Saves a texture to file. + + The texture to save. + The format the texture will be saved as. + Name of the destination output file where the texture will be saved. + A object describing the result of the operation. + + + + Saves a texture to a stream. + + The texture to save. + The format the texture will be saved as. + Destination memory stream where the image will be saved. + A object describing the result of the operation. + + + + Load a texture from a texture. + + Pointer to the source texture. See . + Pointer to the destination texture. See . + Pointer to texture loading parameters. See . + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10LoadTextureFromTexture([None] ID3D10Resource* pSrcTexture,[None] D3DX10_TEXTURE_LOAD_INFO* pLoadInfo,[None] ID3D10Resource* pDstTexture) + + + + Returns a DXGI Surface for this resource. + + The buffer interface, or null on failure. + + + + Calculates a subresource index. + + The index of the desired mip slice. + The index of the desired array slice. + The total number of mip levels. + The subresource index (equivalent to mipSlice + (arraySlice * mipLevels)). + + + + Generates mipmap chain using a particular texture filter. + + The texture object to be filtered. See . + The mipmap level whose data is used to generate the rest of the mipmap chain. + Flags controlling how each miplevel is filtered (or D3DX10_DEFAULT for D3DX10_FILTER_BOX). See . + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10FilterTexture([None] ID3D10Resource* pTexture,[None] int SrcLevel,[None] int MipFilter) + + + + Calculate the MipSize + + + + + + + + Get the type of the resource. + + void ID3D10Resource::GetType([Out] D3D10_RESOURCE_DIMENSION* rType) + + + + Get the eviction priority of a resource. + + + This method is a wrapper for {{GetEvictionPriority}} and is provided in the interface for convenience. + + int ID3D10Resource::GetEvictionPriority() + + + + Initializes a new instance of the class. + + The device with which to associate the buffer. + The description of the buffer. + + + + Initializes a new instance of the class. + + The device with which to associate the buffer. + Initial data used to initialize the buffer. + The description of the buffer. + + + + Initializes a new instance of the class. + + The device with which to associate the buffer. + The size, in bytes, of the buffer. + The usage pattern for the buffer. + Flags specifying how the buffer will be bound to the pipeline. + Flags specifying how the buffer will be accessible from the CPU. + Miscellaneous resource options. + + + + Initializes a new instance of the class. + + The device with which to associate the buffer. + Initial data used to initialize the buffer. + The size, in bytes, of the buffer. + The usage pattern for the buffer. + Flags specifying how the buffer will be bound to the pipeline. + Flags specifying how the buffer will be accessible from the CPU. + Miscellaneous resource options. + + + + Get a reference to the data contained in the resource and deny GPU access to the resource. + + + For the CPU to write the contents of a resource, the resource must be created with the dynamic usage flag, D3D10_USAGE_DYNAMIC. To both read and write those contents, the resource must be created with the staging usage flag, D3D10_USAGE_STAGING. (For more information about these flags, see .) ID3D10Buffer::Map will retrieve a reference to the resource data. For a discussion on how to access resources efficiently, see {{Copying and Accessing Resource Data (Direct3D 10)}}. Call to signify that the application has finished accessing the resource. ID3D10Buffer::Map has a few other restrictions. For example: The same buffer cannot be mapped multiple times; in other words, do not call ID3D10Buffer::Map on a buffer that is already mapped. Any buffer that is bound to the pipeline must be unmapped before any rendering operation (that is, ) can be executed. Differences between Direct3D 9 and Direct3D 10: ID3D10Buffer::Map in Direct3D 10 is analogous to resource {{Lock}} in Direct3D 9. ? + + Flag that specifies the CPU's permissions for the reading and writing of a resource. For possible values, see . + If this function succeeds returns a with the size this buffer. + HRESULT ID3D10Buffer::Map([In] D3D10_MAP MapType,[In] int MapFlags,[Out] void** ppData) + + + + Get a reference to the data contained in the resource and deny GPU access to the resource. + + + For the CPU to write the contents of a resource, the resource must be created with the dynamic usage flag, D3D10_USAGE_DYNAMIC. To both read and write those contents, the resource must be created with the staging usage flag, D3D10_USAGE_STAGING. (For more information about these flags, see .) ID3D10Buffer::Map will retrieve a reference to the resource data. For a discussion on how to access resources efficiently, see {{Copying and Accessing Resource Data (Direct3D 10)}}. Call to signify that the application has finished accessing the resource. ID3D10Buffer::Map has a few other restrictions. For example: The same buffer cannot be mapped multiple times; in other words, do not call ID3D10Buffer::Map on a buffer that is already mapped. Any buffer that is bound to the pipeline must be unmapped before any rendering operation (that is, ) can be executed. Differences between Direct3D 9 and Direct3D 10: ID3D10Buffer::Map in Direct3D 10 is analogous to resource {{Lock}} in Direct3D 9. ? + + Flag that specifies the CPU's permissions for the reading and writing of a resource. For possible values, see . + Flag that specifies what the CPU should do when the GPU is busy (see ). This flag is optional. + If this function succeeds returns a with the size this buffer. + HRESULT ID3D10Buffer::Map([In] D3D10_MAP MapType,[In] int MapFlags,[Out] void** ppData) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a reference to the data contained in the resource and deny GPU access to the resource. + + + For the CPU to write the contents of a resource, the resource must be created with the dynamic usage flag, D3D10_USAGE_DYNAMIC. To both read and write those contents, the resource must be created with the staging usage flag, D3D10_USAGE_STAGING. (For more information about these flags, see .) ID3D10Buffer::Map will retrieve a reference to the resource data. For a discussion on how to access resources efficiently, see {{Copying and Accessing Resource Data (Direct3D 10)}}. Call to signify that the application has finished accessing the resource. ID3D10Buffer::Map has a few other restrictions. For example: The same buffer cannot be mapped multiple times; in other words, do not call ID3D10Buffer::Map on a buffer that is already mapped. Any buffer that is bound to the pipeline must be unmapped before any rendering operation (that is, ) can be executed. Differences between Direct3D 9 and Direct3D 10: ID3D10Buffer::Map in Direct3D 10 is analogous to resource {{Lock}} in Direct3D 9. ? + + Flag that specifies the CPU's permissions for the reading and writing of a resource. For possible values, see . + Flag that specifies what the CPU should do when the GPU is busy (see ). This flag is optional. + Pointer to the buffer resource data. + If this function succeeds, it returns S_OK. The following list contains some of the reasons that Map can fail: If MapFlags specifies D3D10_MAP_FLAG_DO_NOT_WAIT and the GPU is not yet finished with the resource, ID3D10Buffer::Map returns DXGI_ERROR_WAS_STILL_DRAWING. ID3D10Buffer::Map returns DXGI_ERROR_DEVICE_REMOVED if MapType includes any flags that permit reading and the hardware device (that is, the video card) has been removed. For more information about the preceding return values, see . + HRESULT ID3D10Buffer::Map([In] D3D10_MAP MapType,[In] D3D10_MAP_FLAG MapFlags,[Out] void** ppData) + + + + Invalidate the reference to the resource retrieved by and reenable GPU access to the resource. + + + Differences between Direct3D 9 and Direct3D 10: Unmap() in Direct3D 10 is analogous to resource Unlock() in Direct3D 9. ? + + void ID3D10Buffer::Unmap() + + + + Get the properties of a buffer resource. + + Pointer to a resource description (see ) filled in by the method. This reference cannot be NULL. + void ID3D10Buffer::GetDesc([Out] D3D10_BUFFER_DESC* pDesc) + + + + Get the properties of a buffer resource. + + void ID3D10Buffer::GetDesc([Out] D3D10_BUFFER_DESC* pDesc) + + + + Describes a {{buffer}} resource. + + + This structure is used by to create buffer resources. In addition to this structure, there is also a derived structure in D3D10.h (CD3D10_BUFFER_DESC) which behaves like an inherited class to help create a buffer description. + + D3D10_BUFFER_DESC + + + + Initializes a new instance of the struct. + + The size in bytes. + The usage. + The bind flags. + The cpu access flags. + The option flags. + + + + Size of the buffer in bytes. + + int ByteWidth + + + + Identify how the buffer is expected to be read from and written to. Frequency of update is a key factor. The most common value is typically D3D10_USAGE_DEFAULT; see for all possible values. + + D3D10_USAGE Usage + + + + Identify how the buffer will be bound to the {{pipeline}}. Applications can logicaly OR flags together (see ) to indicate that the buffer can be accessed in different ways. + + D3D10_BIND_FLAG BindFlags + + + + CPU access flags (see ) or 0 if no CPU access is necessary. Applications can logicaly OR flags together. + + D3D10_CPU_ACCESS_FLAG CPUAccessFlags + + + + Miscellaneous flags (see ) or 0 if unused. Applications can logically OR flags together. + + D3D10_RESOURCE_MISC_FLAG MiscFlags + + + + The device interface represents a virtual adapter for Direct3D 10.0; it is used to perform rendering and create Direct3D resources. + + ID3D10Device + + + + Constructor for a D3D10 Device. See for more information. + + + + + + Constructor for a D3D10 Device. See for more information. + + + + + + Constructor for a D3D10 Device. See for more information. + + + + + + + Constructor for a D3D10 Device. See for more information. + + + + + + + Set all the elements in a render target to one value. + + + Applications that wish to clear a render target to a specific integer value bit pattern should render a screen-aligned quad instead of using this method. The reason for this is because this method accepts as input a floating point value, which may not have the same bit pattern as the original integer. Differences between Direct3D 9 and Direct3D 10: Unlike Direct3D 9, the full extent of the resource view is always cleared. Viewport and scissor settings are not applied. ? + + Pointer to the rendertarget. + A 4-component array that represents the color to fill the render target with. + void ID3D10Device::ClearRenderTargetView([In] ID3D10RenderTargetView* pRenderTargetView,[In] const float* ColorRGBA) + + + + Initializes a new instance of the class along with a new used for rendering. + + The type of device to create. + A list of runtime layers to enable. + Details used to create the swap chain. + When the method completes, contains the created device instance. + When the method completes, contains the created swap chain instance. + A object describing the result of the operation. + + + + Initializes a new instance of the class along with a new used for rendering. + + The video adapter on which the device should be created. + A list of runtime layers to enable. + Details used to create the swap chain. + When the method completes, contains the created device instance. + When the method completes, contains the created swap chain instance. + A object describing the result of the operation. + + + + This overload has been deprecated. Use one of the alternatives that does not take both an adapter and a driver type. + + + + + Get the type, name, units of measure, and a description of an existing counter. + + The counter description. + Description of the counter + + + + Get the rendering predicate state. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + a boolean to fill with the predicate comparison value. FALSE upon device creation. + a reference to a predicate (see ). + void ID3D10Device::GetPredication([Out, Optional] ID3D10Predicate** ppPredicate,[Out, Optional] BOOL* pPredicateValue) + + + + Give a device access to a shared resource created on a different Direct3d device. + + The type of the resource we are gaining access to. + A resource handle. See remarks. + + This method returns a reference to the resource we are gaining access to. + + + To share a resource between two Direct3D 10 devices the resource must have been created with the flag, if it was created using the ID3D10Device interface. If it was created using the IDXGIDevice interface, then the resource is always shared. The REFIID, or GUID, of the interface to the resource can be obtained by using the __uuidof() macro. For example, __uuidof(ID3D10Buffer) will get the GUID of the interface to a buffer resource. When sharing a resource between two Direct3D 10 devices the unique handle of the resource can be obtained by querying the resource for the interface and then calling {{GetSharedHandle}}. + IDXGIResource* pOtherResource(NULL); + hr = pOtherDeviceResource->QueryInterface( __uuidof(IDXGIResource), (void**)&pOtherResource ); + HANDLE sharedHandle; + pOtherResource->GetSharedHandle(&sharedHandle); + The only resources that can be shared are 2D non-mipmapped textures. To share a resource between a Direct3D 9 device and a Direct3D 10 device the texture must have been created using the pSharedHandle argument of {{CreateTexture}}. The shared Direct3D 9 handle is then passed to OpenSharedResource in the hResource argument. The following code illustrates the method calls involved. + sharedHandle = NULL; // must be set to NULL to create, can use a valid handle here to open in D3D9 + pDevice9->CreateTexture(..., pTex2D_9, &sharedHandle); + ... + pDevice10->OpenSharedResource(sharedHandle, __uuidof(ID3D10Resource), (void**)(&tempResource10)); + tempResource10->QueryInterface(__uuidof(ID3D10Texture2D), (void**)(&pTex2D_10)); + tempResource10->Release(); + // now use pTex2D_10 with pDevice10 + Textures being shared from D3D9 to D3D10 have the following restrictions. Textures must be 2D Only 1 mip level is allowed Texture must have default usage Texture must be write only MSAA textures are not allowed Bind flags must have SHADER_RESOURCE and RENDER_TARGET set Only R10G10B10A2_UNORM, R16G16B16A16_FLOAT and R8G8B8A8_UNORM formats are allowed If a shared texture is updated on one device must be called on that device. + + HRESULT ID3D10Device::OpenSharedResource([In] void* hResource,[In] GUID* ReturnedInterface,[Out, Optional] void** ppResource) + + + + Copy the entire contents of the source resource to the destination resource using the GPU. + + + This method is unusual in that it causes the GPU to perform the copy operation (similar to a memcpy by the CPU). As a result, it has a few restrictions designed for improving performance. For instance, the source and destination resources: Must be different resources. Must be the same {{type}}. Must have identical dimensions (including width, height, depth, and size as appropriate). Will only be copied. CopyResource does not support any stretch, color key, blend, or format conversions. Must have compatible {{formats}}, which means the formats must be identical or at least from the same type group. For example, a DXGI_FORMAT_R32G32B32_FLOAT texture can be copied to an DXGI_FORMAT_R32G32B32_UINT texture since both of these formats are in the DXGI_FORMAT_R32G32B32_TYPELESS group. May not be currently {{mapped}}. {{Immutable}}, and {{depth-stencil}} resources cannot be used as a destination. Resources created with {{multisampling capability}} cannot be used as either a source or destination. The method is an asynchronous call which may be added to the command-buffer queue. This attempts to remove pipeline stalls that may occur when copying data. See {{performance considerations}} for more details. An application that only needs to copy a portion of the data in a resource should use instead. Differences between Direct3D 10 and Direct3D 10.1: Direct3D 10.1 enables depth-stencil resources to be used as either a source or destination. Direct3D 10.1 enables multisampled resources to be used as source and destination only if both source and destination have identical multisampled count and quality. If source and destination differ in multisampled count and quality or if the source is multisampled and the destination is not multisampled (or vice versa), the call to ID3D10Device::CopyResource fails. It is possible to copy between prestructured+typed resources and block-compressed textures. See {{Format Conversion using Direct3D 10.1}}. ? + + A reference to the source resource (see ). + A reference to the destination resource (see ). + void ID3D10Device::CopyResource([In] ID3D10Resource* pDstResource,[In] ID3D10Resource* pSrcResource) + + + + Copy a region from a source resource to a destination resource. + + + The source box must be within the size of the source resource. The destination location is an absolute value (not a relative value). The destination location can be offset from the source location; however, the size of the region to copy (including the destination location) must fit in the destination resource. If the resources are buffers, all coordinates are in bytes; if the resources are textures, all coordinates are in texels. {{D3D10CalcSubresource}} is a helper function for calculating subresource indexes. CopySubresourceRegion performs the copy on the GPU (similar to a memcpy by the CPU). As a consequence, the source and destination resources must meet the following criteria: Must be different subresources (although they can be from the same resource). Must be the same {{type}}. Must have compatible {{formats}} (the formats must either be identical or be from the same type group). For example, a DXGI_FORMAT_R32G32B32_FLOAT texture can be copied to an DXGI_FORMAT_R32G32B32_UINT texture because both of these formats are in the DXGI_FORMAT_R32G32B32_TYPELESS group. May not be currently {{mapped}}. CopySubresourceRegion supports only copy; it does not support any stretch, color key, blend, or format conversions. An application that needs to copy an entire resource should use instead. CopySubresourceRegion is an asynchronous call that the runtime can add to the command-buffer queue. This asynchronous behaviorattempts to remove pipeline stalls that may occur when copying data. See {{performance considerations}} for more details. Differences between Direct3D 10 and Direct3D 10.1: Direct3D 10 has the following limitations: You cannot use a depth-stencil resource as a destination. You cannot use an immutable resource as a destination. You cannot use a multisampled texture as either a source or a destination Direct3D 10.1 has added support for the following features: You can use a depth-stencil buffer as a source or a destination. You can use multisampled resources as source and destination only if both source and destination have identical multisampled count and quality. If source and destination differ in multisampled count and quality or if the source is multisampled and the destination is not multisampled (or vice versa), the call to ID3D10Device::CopySubresourceRegion fails. You can copy between uncompressed and compressed resources. During copy, the format conversions that are specified in {{Format Conversion using Direct3D 10.1}} are supported automatically. The uncompressed resource must be at least prestructured, and typed. You must also account for the difference between the virtual and the physical size of the mipmaps levels. ? Note??If you use CopySubresourceRegion with a depth-stencil buffer or a multisampled resource, you must copy the whole subresource. You must also pass 0 to the DstX, DstY, and DstZ parameters and NULL to the pSrcBox parameter. In addition, source and destination resources, which are represented by the pSrcResource and pDstResource parameters respectively, must have identical sample count values. Example The following code snippet copies a box (located at (120,100),(200,220)) from a source texture into a reqion (130,120),(210,240) in a destination texture. + D3D10_BOX sourceRegion; + sourceRegion.left = 120; + sourceRegion.right = 200; + sourceRegion.top = 100; + sourceRegion.bottom = 220; + sourceRegion.front = 0; + sourceRegion.back = 1; pd3dDevice->CopySubresourceRegion( pDestTexture, 0, 130, 120, 0, pSourceTexture, 0, &sourceRegion ); + + Notice that, for a 2D texture, front and back are always set to 0 and 1 respectively. + + A reference to the source resource (see ). + index of the source. + A 3D box (see ) that defines the source subresources that can be copied. If NULL, the entire source subresource is copied. The box must fit within the source resource. + A reference to the destination resource (see ). + index of the destination. + The x coordinate of the upper left corner of the destination region. + The y coordinate of the upper left corner of the destination region. + The z coordinate of the upper left corner of the destination region. For a 1D or 2D subresource, this must be zero. + void ID3D10Device::CopySubresourceRegion([In] ID3D10Resource* pDstResource,[In] int DstSubresource,[In] int DstX,[In] int DstY,[In] int DstZ,[In] ID3D10Resource* pSrcResource,[In] int SrcSubresource,[In, Optional] const D3D10_BOX* pSrcBox) + + + + Copy a multisampled resource into a non-multisampled resource. This API is most useful when re-using the resulting rendertarget of one render pass as an input to a second render pass. + + + Both the source and destination resources must be the same {{resource type}} and have the same dimensions. The source and destination must have compatible formats. There are three scenarios for this: ScenarioRequirements Source and destination are prestructured and typedBoth the source and destination must have identical formats and that format must be specified in the Format parameter. One resource is prestructured and typed and the other is prestructured and typelessThe typed resource must have a format that is compatible with the typeless resource (i.e. the typed resource is DXGI_FORMAT_R32_FLOAT and the typeless resource is DXGI_FORMAT_R32_TYPELESS). The format of the typed resource must be specified in the Format parameter. Source and destination are prestructured and typelessBoth the source and desintation must have the same typeless format (i.e. both must have DXGI_FORMAT_R32_TYPELESS), and the Format parameter must specify a format that is compatible with the source and destination (i.e. if both are DXGI_FORMAT_R32_TYPELESS then DXGI_FORMAT_R32_FLOAT or DXGI_FORMAT_R32_UINT could be specified in the Format parameter). ? + + Source resource. Must be multisampled. + The source subresource of the source resource. + Destination resource. Must be a created with the flag and be single-sampled. See . + A zero-based index, that identifies the destination subresource. See {{D3D10CalcSubresource}} for more details. + that indicates how the multisampled resource will be resolved to a single-sampled resource. See remarks. + void ID3D10Device::ResolveSubresource([In] ID3D10Resource* pDstResource,[In] int DstSubresource,[In] ID3D10Resource* pSrcResource,[In] int SrcSubresource,[In] DXGI_FORMAT Format) + + + + Copies data from the CPU to to a non-mappable subresource region. + + The source data. + The destination resource. + The destination subresource. + + + + Copies data from the CPU to to a non-mappable subresource region. + + The source data. + The destination resource. + The destination subresource. + The destination region within the resource. + + + + Initializes a new instance of the class. + + The native pointer. + + + Update nested inner interfaces pointer + + + + Draw indexed, non-instanced primitives. + + + A {{draw API}} submits work to the rendering pipeline. If the sum of both indices is negative, the result of the function call is undefined. + + Number of indices to draw. + Index of the first index to use when accesssing the vertex buffer; begin at StartIndexLocation to index vertices from the vertex buffer. + Offset from the start of the vertex buffer to the first vertex. + void ID3D10Device::DrawIndexed([In] int IndexCount,[In] int StartIndexLocation,[In] int BaseVertexLocation) + + + + Draw non-indexed, non-instanced primitives. + + + A {{draw API}} submits work to the rendering pipeline. The vertex data for a draw call normally comes from a vertex buffer that is bound to the pipeline. However, you could also provide the vertex data from a shader that has vertex data marked with the SV_VertexId?{{system-value semantic}}. + + Number of vertices to draw. + Index of the first vertex, which is usually an offset in a vertex buffer; it could also be used as the first vertex id generated for a shader parameter marked with the SV_TargetId?{{system-value semantic}}. + void ID3D10Device::Draw([In] int VertexCount,[In] int StartVertexLocation) + + + + Draw indexed, instanced primitives. + + + A {{draw API}} submits work to the rendering pipeline. Instancing may extend performance by reusing the same geometry to draw multiple objects in a scene. One example of instancing could be to draw the same object with different positions and colors. Indexing requires multiple vertex buffers: at least one for per-vertex data and a second buffer for per-instance data. For an example of instancing, see the {{Instancing10 Sample}}. + + Size of the index buffer used in each instance. + Number of instances to draw. + Index of the first index. + Index of the first vertex. The index is signed, which allows a negative index. If the negative index plus the index value from the index buffer are less than 0, the result is undefined. + Index of the first instance. + void ID3D10Device::DrawIndexedInstanced([In] int IndexCountPerInstance,[In] int InstanceCount,[In] int StartIndexLocation,[In] int BaseVertexLocation,[In] int StartInstanceLocation) + + + + Draw non-indexed, instanced primitives. + + + A {{draw API}} submits work to the rendering pipeline. Instancing may extend performance by reusing the same geometry to draw multiple objects in a scene. One example of instancing could be to draw the same object with different positions and colors. For an example of instancing, see the {{Instancing10 Sample}}. The vertex data for an instanced draw call normally comes from a vertex buffer that is bound to the pipeline. However, you could also provide the vertex data from a shader that has instanced data identified with a {{system-value semantic}} (SV_InstanceID). + + Number of vertices to draw. + Number of instances to draw. + Index of the first vertex. + Index of the first instance. + void ID3D10Device::DrawInstanced([In] int VertexCountPerInstance,[In] int InstanceCount,[In] int StartVertexLocation,[In] int StartInstanceLocation) + + + + Set a rendering predicate. + + + The predicate must be in the "issued" or "signaled" state to be used for predication. While the predicate is set for predication, calls to and are invalid. This method is used to denote that subsequent rendering and resource manipulation commands are not actually performed if the resulting Predicate data of the Predicate is equal to the PredicateValue. However, some Predicates are only hints, so they may not actually prevent operations from being performed. The primary usefulness of Predication is to allow an application to issue graphics commands without taking the performance hit of spinning, waiting for to return. So, Predication can occur while ID3D10Asynchronous::GetData returns S_FALSE. Another way to think of it: an application can also use Predication as a fallback, if it is possible that ID3D10Asynchronous::GetData returns S_FALSE. If ID3D10Asynchronous::GetData returns S_OK, the application can skip calling the graphics commands manually with it's own application logic. + + Pointer to a predicate (see ). A NULL value indicates "no" predication; in this case, the value of PredicateValue is irrelevent but will be preserved for . + If TRUE, rendering will be affected by when the predicate's conditions are met. If FALSE, rendering will be affected when the conditions are not met. + void ID3D10Device::SetPredication([In, Optional] ID3D10Predicate* pPredicate,[In] BOOL PredicateValue) + + + + Draw geometry of an unknown size that was created by the geometry shader stage. See remarks. + + + A {{draw API}} submits work to the rendering pipeline. After data has been streamed out to {{SO stage}} buffers, those buffers can be again bound to the Input Assembler stage at input slot 0 and DrawAuto will draw them without the application needing to know the amount of data that was written to the buffers. A measurement of the amount of data written to the SO stage buffers is maintained internally when the data is streamed out. This means that the CPU does not need to fetch the measurement before re-binding the data that was streamed as input data. Although this amount is tracked internally, it is still the responsibility of applications to use input layouts to describe the format of the data in the SO stage buffers so that the layouts are available when the buffers are again bound to the input assembler. The following diagram shows the DrawAuto process. ? Diagram of DrawAuto as data moves through several stages to a buffer and then back to the Input Assembler stage ? Calling DrawAuto does not change the state of the streaming-output buffers that were bound again as inputs. DrawAuto only works when drawing with one input buffer bound as an input to the IA stage at slot 0. Applications must create the SO buffer resource with both binding flags, and D3D10_BIND_STREAM_OUTPUT. This API does not support indexing or instancing. If an application needs to retrieve the size of the streaming-output buffer, it can query for statistics on streaming output by using . Example of using DrawAuto can be found in the {{ParticlesGS Sample}} and {{PipesGS Sample}}. + + void ID3D10Device::DrawAuto() + + + + Copy a region from a source resource to a destination resource. + + + The source box must be within the size of the source resource. The destination location is an absolute value (not a relative value). The destination location can be offset from the source location; however, the size of the region to copy (including the destination location) must fit in the destination resource. If the resources are buffers, all coordinates are in bytes; if the resources are textures, all coordinates are in texels. {{D3D10CalcSubresource}} is a helper function for calculating subresource indexes. CopySubresourceRegion performs the copy on the GPU (similar to a memcpy by the CPU). As a consequence, the source and destination resources must meet the following criteria: Must be different subresources (although they can be from the same resource). Must be the same {{type}}. Must have compatible {{formats}} (the formats must either be identical or be from the same type group). For example, a DXGI_FORMAT_R32G32B32_FLOAT texture can be copied to an DXGI_FORMAT_R32G32B32_UINT texture because both of these formats are in the DXGI_FORMAT_R32G32B32_TYPELESS group. May not be currently {{mapped}}. CopySubresourceRegion supports only copy; it does not support any stretch, color key, blend, or format conversions. An application that needs to copy an entire resource should use instead. CopySubresourceRegion is an asynchronous call that the runtime can add to the command-buffer queue. This asynchronous behaviorattempts to remove pipeline stalls that may occur when copying data. See {{performance considerations}} for more details. Differences between Direct3D 10 and Direct3D 10.1: Direct3D 10 has the following limitations: You cannot use a depth-stencil resource as a destination. You cannot use an immutable resource as a destination. You cannot use a multisampled texture as either a source or a destination Direct3D 10.1 has added support for the following features: You can use a depth-stencil buffer as a source or a destination. You can use multisampled resources as source and destination only if both source and destination have identical multisampled count and quality. If source and destination differ in multisampled count and quality or if the source is multisampled and the destination is not multisampled (or vice versa), the call to ID3D10Device::CopySubresourceRegion fails. You can copy between uncompressed and compressed resources. During copy, the format conversions that are specified in {{Format Conversion using Direct3D 10.1}} are supported automatically. The uncompressed resource must be at least prestructured, and typed. You must also account for the difference between the virtual and the physical size of the mipmaps levels. ? Note??If you use CopySubresourceRegion with a depth-stencil buffer or a multisampled resource, you must copy the whole subresource. You must also pass 0 to the DstX, DstY, and DstZ parameters and NULL to the pSrcBox parameter. In addition, source and destination resources, which are represented by the pSrcResource and pDstResource parameters respectively, must have identical sample count values. Example The following code snippet copies a box (located at (120,100),(200,220)) from a source texture into a reqion (130,120),(210,240) in a destination texture. + D3D10_BOX sourceRegion; + sourceRegion.left = 120; + sourceRegion.right = 200; + sourceRegion.top = 100; + sourceRegion.bottom = 220; + sourceRegion.front = 0; + sourceRegion.back = 1; pd3dDevice->CopySubresourceRegion( pDestTexture, 0, 130, 120, 0, pSourceTexture, 0, &sourceRegion ); + + Notice that, for a 2D texture, front and back are always set to 0 and 1 respectively. + + A reference to the destination resource (see ). + index of the destination. + The x coordinate of the upper left corner of the destination region. + The y coordinate of the upper left corner of the destination region. + The z coordinate of the upper left corner of the destination region. For a 1D or 2D subresource, this must be zero. + A reference to the source resource (see ). + index of the source. + A 3D box (see ) that defines the source subresources that can be copied. If NULL, the entire source subresource is copied. The box must fit within the source resource. + void ID3D10Device::CopySubresourceRegion([In] ID3D10Resource* pDstResource,[In] int DstSubresource,[In] int DstX,[In] int DstY,[In] int DstZ,[In] ID3D10Resource* pSrcResource,[In] int SrcSubresource,[In, Optional] const D3D10_BOX* pSrcBox) + + + + Copy the entire contents of the source resource to the destination resource using the GPU. + + + This method is unusual in that it causes the GPU to perform the copy operation (similar to a memcpy by the CPU). As a result, it has a few restrictions designed for improving performance. For instance, the source and destination resources: Must be different resources. Must be the same {{type}}. Must have identical dimensions (including width, height, depth, and size as appropriate). Will only be copied. CopyResource does not support any stretch, color key, blend, or format conversions. Must have compatible {{formats}}, which means the formats must be identical or at least from the same type group. For example, a DXGI_FORMAT_R32G32B32_FLOAT texture can be copied to an DXGI_FORMAT_R32G32B32_UINT texture since both of these formats are in the DXGI_FORMAT_R32G32B32_TYPELESS group. May not be currently {{mapped}}. {{Immutable}}, and {{depth-stencil}} resources cannot be used as a destination. Resources created with {{multisampling capability}} cannot be used as either a source or destination. The method is an asynchronous call which may be added to the command-buffer queue. This attempts to remove pipeline stalls that may occur when copying data. See {{performance considerations}} for more details. An application that only needs to copy a portion of the data in a resource should use instead. Differences between Direct3D 10 and Direct3D 10.1: Direct3D 10.1 enables depth-stencil resources to be used as either a source or destination. Direct3D 10.1 enables multisampled resources to be used as source and destination only if both source and destination have identical multisampled count and quality. If source and destination differ in multisampled count and quality or if the source is multisampled and the destination is not multisampled (or vice versa), the call to ID3D10Device::CopyResource fails. It is possible to copy between prestructured+typed resources and block-compressed textures. See {{Format Conversion using Direct3D 10.1}}. ? + + A reference to the destination resource (see ). + A reference to the source resource (see ). + void ID3D10Device::CopyResource([In] ID3D10Resource* pDstResource,[In] ID3D10Resource* pSrcResource) + + + + The CPU copies data from memory to a {{subresource}} created in non-mappable memory. See remarks. + + + For a shader-constant buffer; set pDstBox to NULL. It is not possible to use this method to partially update a shader-constant buffer. A resource cannot be used as a destination if: the resource is created with {{immutable}} usage. the resource is created as a {{depth-stencil resource}}. the resource is created with multisampling capability (see ). When UpdateSubresource returns, the application is free to change or even free the data pointed to by pSrcData because the method has already copied/snapped away the original contents. The performance of UpdateSubresource depends on whether or not there is contention for the destination resource. For example, contention for a vertex buffer resource occurs when the application executes a Draw call and later calls UpdateSubresource on the same vertex buffer before the Draw call is actually executed by the GPU. When there is contention for the resource, UpdateSubresource will perform 2 copies of the source data. First, the data is copied by the CPU to a temporary storage space accessible by the command buffer. This copy happens before the method returns. A second copy is then performed by the GPU to copy the source data into non-mappable memory. This second copy happens asynchronously because it is executed by GPU when the command buffer is flushed. When there is no resource contention, the behavior of UpdateSubresource is dependent on which is faster (from the CPU's perspective): copying the data to the command buffer and then having a second copy execute when the command buffer is flushed, or having the CPU copy the data to the final resource location. This is dependent on the architecture of the underlying system. To better understand the source row pitch and source depth pitch parameters, consider the following illustration of a 3D volume texture. ? Illustration of a 3D volume texture ? Each block in this visual represents an element of data, and the size of each element is dependent on the resource's format. For example, if the resource format is DXGI_FORMAT_R32G32B32A32_FLOAT, then the size of each element would be 128 bits, or 16 bytes. This 3D volume texture has a width of two, a height of three, and a depth of four. To calculate the source row pitch and source depth pitch for a given resource, use the following formulas: Source Row Pitch = [size of one element in bytes] * [number of elements in one row] Source Depth Pitch = [Source Row Pitch] * [number of rows (height)] In the case of this example 3D volume texture where the size of each element is 16 bytes, the formulas are as follows: Source Row Pitch = 16 * 2 = 32 Source Depth Pitch = 16 * 2 * 3 = 96 The following illustration shows the resource as it is laid out in memory. ? Illustration of a 3D volume texture in memory ? For example, the following code snippet shows how to specify a destination region in a 2D texture. Assume the destination texture is 512x512 and the operation will copy the data pointed to by pData to [(120,100)..(200,220)] in the destination texture. Also assume that rowPitch has been initialized with the proper value (as explained above). Front and back are set to 0 and 1 respectively, because by having front equal to back, the box is technically empty. + D3D10_BOX destRegion; + destRegion.left = 120; + destRegion.right = 200; + destRegion.top = 100; + destRegion.bottom = 220; + destRegion.front = 0; + destRegion.back = 1; pd3dDevice->UpdateSubresource( pDestTexture, 0, &destRegion, pData, rowPitch, 0 ); + + The 1D case is similar. The following snippet shows how to specify a destination region in a 1D texture. Use the same assumptions as above, except that the texture is 512 in length. + D3D10_BOX destRegion; + destRegion.left = 120 + destRegion.right = 200; + destRegion.top = 0; + destRegion.bottom = 1; + destRegion.front = 0; + destRegion.back = 1; pd3dDevice->UpdateSubresource( pDestTexture, 0, &destRegion, pData, rowPitch, 0 ); + + Differences between Direct3D 10 and Direct3D 10.1: Direct3D 10.1 enables depth-stencil resources to be used as either a source or destination. ? + + A reference to the destination resource (see ). + A zero-based index, that identifies the destination subresource. See {{D3D10CalcSubresource}} for more details. + A box that defines the portion of the destination subresource to copy the resource data into. Coordinates are in bytes for buffers and in texels for textures. If NULL, the data is written to the destination subresource with no offset. The dimensions of the source must fit the destination (see ). + A reference to the source data in memory. + The size of one row of the source data. + The size of one depth slice of source data. + void ID3D10Device::UpdateSubresource([In] ID3D10Resource* pDstResource,[In] int DstSubresource,[In, Optional] const D3D10_BOX* pDstBox,[In] const void* pSrcData,[In] int SrcRowPitch,[In] int SrcDepthPitch) + + + + Set all the elements in a render target to one value. + + + Applications that wish to clear a render target to a specific integer value bit pattern should render a screen-aligned quad instead of using this method. The reason for this is because this method accepts as input a floating point value, which may not have the same bit pattern as the original integer. Differences between Direct3D 9 and Direct3D 10: Unlike Direct3D 9, the full extent of the resource view is always cleared. Viewport and scissor settings are not applied. ? + + Pointer to the rendertarget. + A 4-component array that represents the color to fill the render target with. + void ID3D10Device::ClearRenderTargetView([In] ID3D10RenderTargetView* pRenderTargetView,[In] const SHARPDX_COLOR4* ColorRGBA) + + + + Clears the depth-stencil resource. + + + Differences between Direct3D 9 and Direct3D 10: Unlike Direct3D 9, the full extent of the resource view is always cleared. Viewport and scissor settings are not applied. ? + + Pointer to the depth stencil to be cleared. + Which parts of the buffer to clear. See . + Clear the depth buffer with this value. This value will be clamped between 0 and 1. + Clear the stencil buffer with this value. + void ID3D10Device::ClearDepthStencilView([In] ID3D10DepthStencilView* pDepthStencilView,[In] D3D10_CLEAR_FLAG ClearFlags,[In] float Depth,[In] byte Stencil) + + + + Generate mipmaps for the given shader resource. + + + GenerateMips may be called on any ID3D10ShaderResourceView in order to generate the lower mipmap levels. GenerateMips uses the largest mipmap level of the view to recursively generate the lower levels of the mip, stopping with the smallest level specified by the view. If the base resource was not created with and , this call has no effect. All video adapters will automatically generate mipmaps if you are using one of the following formats: + DXGI_FORMAT_A8_UNORM + DXGI_FORMAT_R10G10B10A2_UNORM + DXGI_FORMAT_R11G11B10_FLOAT + DXGI_FORMAT_R16_FLOAT + DXGI_FORMAT_R16_SNORM + DXGI_FORMAT_R16_UNORM + DXGI_FORMAT_R16G16_FLOAT + DXGI_FORMAT_R16G16_SNORM + DXGI_FORMAT_R16G16_UNORM + DXGI_FORMAT_R16G16B16A16_FLOAT + DXGI_FORMAT_R16G16B16A16_SNORM + DXGI_FORMAT_R16G16B16A16_UNORM + DXGI_FORMAT_R32_FLOAT + DXGI_FORMAT_R32G32_FLOAT + DXGI_FORMAT_R32G32B32A32_FLOAT + DXGI_FORMAT_R8_SNORM + DXGI_FORMAT_R8_UNORM + DXGI_FORMAT_R8G8_SNORM + DXGI_FORMAT_R8G8_UNORM + DXGI_FORMAT_R8G8B8A8_SNORM + DXGI_FORMAT_R8G8B8A8_UNORM + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB + + Some video adapters will automatically generate mipmaps for this format. + DXGI_FORMAT_R32G32B32_FLOAT + + For all other unsupported formats, this method will silently fail. + + Pointer to an . The mipmaps will be generated for this shader resource. + void ID3D10Device::GenerateMips([In] ID3D10ShaderResourceView* pShaderResourceView) + + + + Copy a multisampled resource into a non-multisampled resource. This API is most useful when re-using the resulting rendertarget of one render pass as an input to a second render pass. + + + Both the source and destination resources must be the same {{resource type}} and have the same dimensions. The source and destination must have compatible formats. There are three scenarios for this: ScenarioRequirements Source and destination are prestructured and typedBoth the source and destination must have identical formats and that format must be specified in the Format parameter. One resource is prestructured and typed and the other is prestructured and typelessThe typed resource must have a format that is compatible with the typeless resource (i.e. the typed resource is DXGI_FORMAT_R32_FLOAT and the typeless resource is DXGI_FORMAT_R32_TYPELESS). The format of the typed resource must be specified in the Format parameter. Source and destination are prestructured and typelessBoth the source and desintation must have the same typeless format (i.e. both must have DXGI_FORMAT_R32_TYPELESS), and the Format parameter must specify a format that is compatible with the source and destination (i.e. if both are DXGI_FORMAT_R32_TYPELESS then DXGI_FORMAT_R32_FLOAT or DXGI_FORMAT_R32_UINT could be specified in the Format parameter). ? + + Destination resource. Must be a created with the flag and be single-sampled. See . + A zero-based index, that identifies the destination subresource. See {{D3D10CalcSubresource}} for more details. + Source resource. Must be multisampled. + The source subresource of the source resource. + that indicates how the multisampled resource will be resolved to a single-sampled resource. See remarks. + void ID3D10Device::ResolveSubresource([In] ID3D10Resource* pDstResource,[In] int DstSubresource,[In] ID3D10Resource* pSrcResource,[In] int SrcSubresource,[In] DXGI_FORMAT Format) + + + + Get the rendering predicate state. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Address of a reference to a predicate (see ). Value stored here will be NULL upon device creation. + Address of a boolean to fill with the predicate comparison value. FALSE upon device creation. + void ID3D10Device::GetPredication([Out, Optional] ID3D10Predicate** ppPredicate,[Out, Optional] BOOL* pPredicateValue) + + + + Get the reason why the device was removed. + + Possible return values include: DXGI_ERROR_DEVICE_HUNG DXGI_ERROR_DEVICE_REMOVED DXGI_ERROR_DEVICE_RESET DXGI_ERROR_DRIVER_INTERNAL_ERROR DXGI_ERROR_INVALID_CALL S_OK For more detail on these return codes, see . + HRESULT ID3D10Device::GetDeviceRemovedReason() + + + + Get the exception-mode flags. + + + Set an exception-mode flag to elevate an error condition to a non-continuable exception. Whenever an error occurs, a Direct3D device enters the DEVICEREMOVED state and if the appropriate exception flag has been set, an exception is raised. A raised exception is designed to terminate an application. Before termination, the last chance an application has to persist data is by using an UnhandledExceptionFilter (see {{Structured Exception Handling}}). In general, UnhandledExceptionFilters are leveraged to try to persist data when an application is crashing (to disk, for example). Any code that executes during an UnhandledExceptionFilter is not guaranteed to reliably execute (due to possible process corruption). Any data that the UnhandledExceptionFilter manages to persist, before the UnhandledExceptionFilter crashes again, should be treated as suspect, and therefore inspected by a new, non-corrupted process to see if it is usable. + + A value that contains one or more exception flags; each flag specifies a condition which will cause an exception to be raised. The flags are listed in {{D3D10_RAISE_FLAG}}. A default value of 0 means there are no flags. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::SetExceptionMode([None] int RaiseFlags) + + + + Get the exception-mode flags. + + + An exception-mode flag is used to elevate an error condition to a non-continuable exception. + + A value that contains one or more exception flags; each flag specifies a condition which will cause an exception to be raised. The flags are listed in {{D3D10_RAISE_FLAG}}. A default value of 0 means there are no flags. + int ID3D10Device::GetExceptionMode() + + + + No documentation. + + No documentation. + No documentation. + No documentation. + No documentation. + HRESULT ID3D10Device::GetPrivateData([In] GUID* guid,[InOut] int* pDataSize,[Out, Buffer, Optional] void* pData) + + + + Set data to a device and associate that data with a guid. + + + The data stored in the device with this method can be retrieved with . The data and guid set with this method will typically be application-defined. If an application uses this method to change the device type using GUID_DeviceType, results are undefined. However, GUID_DeviceType can be used to retrieve the device type using . + + Guid associated with the data. + Size of the data. + Pointer to the data to be stored with this device. If pData is NULL, DataSize must also be 0, and any data previously associated with the guid will be destroyed. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::SetPrivateData([In] GUID* guid,[In] int DataSize,[In, Buffer, Optional] const void* pData) + + + + No documentation. + + No documentation. + No documentation. + No documentation. + HRESULT ID3D10Device::SetPrivateDataInterface([In] GUID* guid,[In, Optional] const IUnknown* pData) + + + + Restore all default device settings; return the device to the state it was in when it was created. This will set all set all input/output resource slots, shaders, input layouts, predications, scissor rectangles, depth-stencil state, rasterizer state, blend state, sampler state, and viewports to NULL. The primitive topology will be set to UNDEFINED. + + void ID3D10Device::ClearState() + + + + Send queued-up commands in the command buffer to the GPU. + + + Most applications will not need to call this method. Calling this method when not necessary will incur a performance penalty. Each call to Flush incurs a significant amount of overhead. When Direct3D state-setting, present, or draw commands are called by an application, those commands are queued into an internal command buffer. Flush sends those commands to the GPU for processing. Normally, these commands are sent to the GPU automatically whenever Direct3D determines that they need to be, such as when the command buffer is full or when mapping a resource. Flush will send the commands manually. Flush should be used when the CPU waits for an arbitrary amount of time (such as when calling {{Sleep}}, {{ID3DX10ThreadPump::WaitForAllItems}}, or {{WaitForVBlank}}. For more information about how flushing works, see {{Accurately Profiling Direct3D API Calls (Direct3D 9)}}. + + void ID3D10Device::Flush() + + + + Create a {{buffer}} (vertex buffer, index buffer, or shader-constant buffer). + + + For example code, see: {{Create a Vertex Buffer}} {{Create an Index Buffer}} + + Pointer to a buffer description (see ). + Pointer to the initialization data (see ); use NULL to allocate space only. + Address of a reference to the buffer created (see ). Set this parameter to NULL to validate the other input parameters (S_FALSE indicates a pass). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::CreateBuffer([In] const D3D10_BUFFER_DESC* pDesc,[In, Optional] const D3D10_SUBRESOURCE_DATA* pInitialData,[Out, Optional] ID3D10Buffer** ppBuffer) + + + + Create an array of 1D textures (see {{Texture1D}}). + + + CreateTexture1D creates a 1D texture resource, which contains an array of 1D textures. The number of textures is specified in the texture description. All textures in a resource must have the same format, size, and number of mipmap levels. All resources are made up of one or more {{subresources}}. To load data into the texture, applications may supply the data initially as part of structure pointed to by pInitialData, or it may use one of the {{Texturing Functions}} supplied by the SDK. + + Pointer to a 1D texture description (see ). To create a typeless resource that can be interpreted at runtime into different, compatible formats, specify a typeless format in the texture description. To generate mipmap levels automatically, set the number of mipmap levels to 0. + Pointer to an array of {{subresource}} descriptions (see ); one for each subresource (ordered by texture array index). Applications may not specify NULL for pInitialData when creating IMMUTABLE resources (see ). If the resource is multisampled, pInitialData must be NULL because multisampled resources cannot be initialized with data when they are created. + Address of a reference to the created texture (see ). Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). + If the method succeeds, the return code is S_OK. See {{Direct3D 10 Return Codes}} for failing error codes. + HRESULT ID3D10Device::CreateTexture1D([In] const D3D10_TEXTURE1D_DESC* pDesc,[In, Buffer, Optional] const D3D10_SUBRESOURCE_DATA* pInitialData,[Out] ID3D10Texture1D** ppTexture1D) + + + + Create an array of 2D textures (see {{Texture2D}}). + + + CreateTexture2D creates a 2D texture resource, which contains an array of 1D textures. The number of textures is specified in the texture description. All textures in a resource must have the same format, size, and number of mipmap levels. All resources are made up of one or more {{subresources}}. To load data into the texture, applications may supply the data initially as part of structure pointed to by pInitialData, or it may use one of the {{Texturing Functions}} supplied by the SDK. + + Pointer to a 2D texture description (see ). To create a typeless resource that can be interpreted at runtime into different, compatible formats, specify a typeless format in the texture description. To generate mipmap levels automatically, set the number of mipmap levels to 0. + Pointer to an array of {{subresource}} descriptions (see ); one for each subresource (ordered by texture array index, then mip level). Applications may not specify NULL for pInitialData when creating IMMUTABLE resources (see ). If the resource is multisampled, pInitialData must be NULL because multisampled resources cannot be initialized with data when they are created. + Address of a reference to the created texture (see ). Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). + If the method succeeds, the return code is S_OK. See {{Direct3D 10 Return Codes}} for failing error codes. + HRESULT ID3D10Device::CreateTexture2D([In] const D3D10_TEXTURE2D_DESC* pDesc,[In, Buffer, Optional] const D3D10_SUBRESOURCE_DATA* pInitialData,[Out] ID3D10Texture2D** ppTexture2D) + + + + Create a single 3D texture (see {{Texture3D}}). + + + CreateTexture3D creates a 3D texture resource, which contains an array of 1D textures. The number of textures is specified in the texture description. All textures in a resource must have the same format, size, and number of mipmap levels. All resources are made up of one or more {{subresources}}. To load data into the texture, applications may supply the data initially as part of structure pointed to by pInitialData, or it may use one of the {{Texturing Functions}} supplied by the SDK. + + Pointer to a 3D texture description (see ). To create a typeless resource that can be interpreted at runtime into different, compatible formats, specify a typeless format in the texture description. To generate mipmap levels automatically, set the number of mipmap levels to 0. + Pointer to an array of {{subresource}} descriptions (see ); one for each subresource (ordered by texture array index, then slice index, then mip level). Applications may not specify NULL for pInitialData when creating IMMUTABLE resources (see ). If the resource is multisampled, pInitialData must be NULL because multisampled resources cannot be initialized with data when they are created. + Address of a reference to the created texture (see ). Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). + If the method succeeds, the return code is S_OK. See {{Direct3D 10 Return Codes}} for failing error codes. + HRESULT ID3D10Device::CreateTexture3D([In] const D3D10_TEXTURE3D_DESC* pDesc,[In, Buffer, Optional] const D3D10_SUBRESOURCE_DATA* pInitialData,[Out] ID3D10Texture3D** ppTexture3D) + + + + Create a shader-resource {{view}} for accessing data in a resource. + + + A resource is made up of one or more {{subresources}}, a view identifies which subresources to allow the pipeline to access. In addition, each resource is bound to the pipeline using a view. A shader-resource view is designed to bind any buffer or texture resource to the {{shader stages}} using the following API methods: {{VSSetShaderResources}}, {{GSSetShaderResources}} and {{PSSetShaderResources}}. Since a view is fully typed, this means that typeless resources become fully typed when bound to the pipeline. + + Pointer to the {{resource}} that will serve as input to a shader. This resource must have been created with the flag. + Pointer to a shader-resource-view description (see ). Set this parameter to NULL to create a view that accesses the entire resource (using the format the resource was created with). + Address of a reference to an . Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::CreateShaderResourceView([In] ID3D10Resource* pResource,[In, Optional] const D3D10_SHADER_RESOURCE_VIEW_DESC* pDesc,[Out, Optional] ID3D10ShaderResourceView** ppSRView) + + + + Create a render-target {{view}} for accessing resource data. + + + A rendertarget view can be bound to the {{output merger stage}} by calling . + + Pointer to the {{resource}} that will serve as the render target. This resource must have been created with the flag. + Pointer to a render-target-view description (see ). Set this parameter to NULL to create a view that accesses mipmap level 0 of the entire resource (using the format the resource was created with). + Address of a reference to an . Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::CreateRenderTargetView([In] ID3D10Resource* pResource,[In, Optional] const D3D10_RENDER_TARGET_VIEW_DESC* pDesc,[Out, Optional] ID3D10RenderTargetView** ppRTView) + + + + Create a depth-stencil {{view}} for accessing resource data. + + + A depth-stencil view can be bound to the {{output-merger stage}} by calling . For more background information, see the {{programming guide page}} about depth stencils. + + Pointer to the {{resource}} that will serve as the depth-stencil surface. This resource must have been created with the flag. + Pointer to a depth-stencil-view description (see ). Set this parameter to NULL to create a view that accesses mipmap level 0 of the entire resource (using the format the resource was created with). + Address of a reference to an . Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::CreateDepthStencilView([In] ID3D10Resource* pResource,[In, Optional] const D3D10_DEPTH_STENCIL_VIEW_DESC* pDesc,[Out, Optional] ID3D10DepthStencilView** ppDepthStencilView) + + + + Create an input-layout object to describe the input-buffer data for the {{input-assembler stage}}. + + + After creating an input layout object, it must be bound to the input-assembler stage before calling a draw API. See {{Getting Started with the Input-Assembler Stage (Direct3D 10)}} for example code. Once an input-layout object is created from a shader signature, the input-layout object can be reused with any other shader that has an identical input signature (semantics included). This can simplify the creation of input-layout objects when you are working with many shaders with identical inputs. If a data type in the input-layout declaration does not match the data type in a shader-input signature, CreateInputLayout will generate a warning during compilation. The warning is simply to call attention to the fact that the data may be reinterpreted when read from a register. You may either disregard this warning (if reinterpretation is intentional) or make the data types match in both declarations to eliminate the warning. The {{Data Conversion Rules}} overview describes the rules applied for data type conversion. Differences between Direct3D 9 and Direct3D 10: Mapping the vertex data to the shader inputs with an input layout is a new way of doing things in Direct3D 10 that improves performance. In Direct3D 10 the vertex data is mapped to the shader inputs when the input layout object is created, whereas in Direct3D 9 this mapping was done at Draw time based on the currently bound vertex declarations, vertex buffers, and vertex shaders. Doing this mapping when the input layout object is created reduces or eliminates extra linkage work for drivers at Draw time because this re-mapping is no longer necessary. ? + + An array of the input-assembler stage input data types; each type is described by an element description (see ). + The number of input-data types in the array of input-elements. + A reference to the compiled shader. To get this reference see {{Getting a Pointer to a Compiled Shader}}. The compiled shader code contains a {{input signature}} which is validated against the array of elements. See remarks. + Size of the compiled shader. + A reference to the input-layout object created (see ). To validate the other input parameters, set this reference to be NULL and verify that the method returns S_FALSE. + If the method succeeds, the return code is S_OK. See {{Direct3D 10 Return Codes}} for failing error codes. + HRESULT ID3D10Device::CreateInputLayout([In, Buffer] const D3D10_INPUT_ELEMENT_DESC* pInputElementDescs,[In] int NumElements,[In] const void* pShaderBytecodeWithInputSignature,[In] SIZE_T BytecodeLength,[Out, Optional] ID3D10InputLayout** ppInputLayout) + + + + Create a vertex-shader object from a compiled shader. + + A reference to the compiled shader. To get this reference see {{Getting a Pointer to a Compiled Shader}}. + Size of the compiled vertex shader. + Address of a reference to an . If this is NULL, all other parameters will be validated, and if all parameters pass validation this API will return S_FALSE instead of S_OK. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::CreateVertexShader([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[Out, Optional] ID3D10VertexShader** ppVertexShader) + + + + Create a geometry shader. + + + Once created, the shader can be set to the device by calling . + + A reference to the compiled shader. To get this reference see {{Getting a Pointer to a Compiled Shader}}. + Size of the compiled geometry shader. + Address of a reference to an . If this is NULL, all other parameters will be validated, and if all parameters pass validation this API will return S_FALSE instead of S_OK. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::CreateGeometryShader([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[Out, Optional] ID3D10GeometryShader** ppGeometryShader) + + + + Create a geometry shader that can write to streaming output buffers. + + A reference to the compiled shader. To get this reference see {{Getting a Pointer to a Compiled Shader}}. + Size of the compiled geometry shader. + Pointer to a array. Cannot be NULL if NumEntries> 0. + The number of entries in the array pointed to by pSODeclaration. Minimum 0, maximum 64. + The size, in bytes, of each element in the array pointed to by pSODeclaration. This parameter is only used when the output slot is 0 for all entries in pSODeclaration. + Address of a reference to an . If this is NULL, all other parameters will be validated, and if all parameters pass validation this API will return S_FALSE instead of S_OK. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::CreateGeometryShaderWithStreamOutput([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In, Buffer, Optional] const D3D10_SO_DECLARATION_ENTRY* pSODeclaration,[In] int NumEntries,[In] int OutputStreamStride,[Out, Optional] ID3D10GeometryShader** ppGeometryShader) + + + + Create a pixel shader. + + + After creating the pixel shader, you can set it to the device using . + + A reference to the compiled shader. To get this reference see {{Getting a Pointer to a Compiled Shader}}. + Size of the compiled pixel shader. + Address of a reference to an . If this is NULL, all other parameters will be validated, and if all parameters pass validation this API will return S_FALSE instead of S_OK. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::CreatePixelShader([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[Out, Optional] ID3D10PixelShader** ppPixelShader) + + + + Create a blend-state object that encapsules blend state for the output-merger stage. + + + An application can create up to 4096 unique blend-state objects. For each object created, the runtime checks to see if a previous object has the same state. If such a previous object exists, the runtime will return a reference to previous instance instead of creating a duplicate object. + + Pointer to a blend-state description (see ). + Address of a reference to the blend-state object created (see ). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::CreateBlendState([In] const D3D10_BLEND_DESC* pBlendStateDesc,[Out, Optional] ID3D10BlendState** ppBlendState) + + + + Create a depth-stencil state object that encapsulates {{depth-stencil test}} information for the output-merger stage. + + + 4096 unique depth-stencil state objects can be created on a device at a time. If an application attempts to create a depth-stencil state with the same description as an already existing depth-stencil state, then the same interface with an incremented reference count will be returned and the total number of unique depth-stencil state objects will stay the same. + + Pointer to a depth-stencil state description (see ). + Address of a reference to the depth-stencil state object created (see ). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::CreateDepthStencilState([In] const D3D10_DEPTH_STENCIL_DESC* pDepthStencilDesc,[Out, Optional] ID3D10DepthStencilState** ppDepthStencilState) + + + + Create a rasterizer state object that tells the {{rasterizer stage}} how to behave. + + + 4096 unique rasterizer state objects can be created on a device at a time. If an application attempts to create a rasterizer state with the same description as an already existing rasterizer state, then the same interface with an incremented reference count will be returned and the total number of unique rasterizer state objects will stay the same. + + Pointer to a rasterizer state description (see ). + Address of a reference to the rasterizer state object created (see ). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::CreateRasterizerState([In] const D3D10_RASTERIZER_DESC* pRasterizerDesc,[Out, Optional] ID3D10RasterizerState** ppRasterizerState) + + + + Create a sampler-state object that encapsulates sampling information for a {{texture}}. + + + 4096 unique sampler state objects can be created on a device at a time. If an application attempts to create a sampler state with the same description as an already existing sampler state, then the same interface with an incremented reference count will be returned and the total number of unique sampler state objects will stay the same. + + Pointer to a sampler state description (see ). + Address of a reference to the sampler state object created (see ). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::CreateSamplerState([In] const D3D10_SAMPLER_DESC* pSamplerDesc,[Out, Optional] ID3D10SamplerState** ppSamplerState) + + + + This interface encapsulates methods for querying information from the GPU. + + + + Pointer to a query description (see ). + Address of a reference to the query object created (see ). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::CreateQuery([In] const D3D10_QUERY_DESC* pQueryDesc,[Out, Optional] ID3D10Query** ppQuery) + + + + Creates a predicate. + + Pointer to a query description where the type of query must be a D3D10_QUERY_SO_OVERFLOW_PREDICATE or D3D10_QUERY_OCCLUSION_PREDICATE (see ). + Address of a reference to a predicate (see ). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::CreatePredicate([In] const D3D10_QUERY_DESC* pPredicateDesc,[Out, Optional] ID3D10Predicate** ppPredicate) + + + + Create a counter object for measuring GPU performance. + + Pointer to a counter description (see ). + Address of a reference to a counter (see ). + If this function succeeds, it will return S_OK. If it fails, possible return values are: S_FALSE, E_OUTOFMEMORY, DXGI_ERROR_UNSUPPORTED, DXGI_ERROR_NONEXCLUSIVE, or E_INVALIDARG. DXGI_ERROR_UNSUPPORTED is returned whenever the application requests to create a well-known counter, but the current device does not support it. DXGI_ERROR_NONEXCLUSIVE indicates that another device object is currently using the counters, so they cannot be used by this device at the moment. E_INVALIDARG is returned whenever an out-of-range well-known or device-dependent counter is requested, or when the simulataneously active counters have been exhausted. + HRESULT ID3D10Device::CreateCounter([In] const D3D10_COUNTER_DESC* pCounterDesc,[Out, Optional] ID3D10Counter** ppCounter) + + + + Get the support of a given format on the installed video device. + + + Most format support is based on the Direct3D feature level. Only a few specific use cases require checking for support. See {{Hardware Support for Direct3D 10 Formats}} and {{Hardware Support for Direct3D 10.1 Formats}} for additional information. + + A enumeration that describes a format for which to check for support. + A bitfield of enumeration values describing how the specified format is supported on the installed device. The values are ORed together. + HRESULT ID3D10Device::CheckFormatSupport([In] DXGI_FORMAT Format,[Out] D3D10_FORMAT_SUPPORT* pFormatSupport) + + + + Get the number of quality levels available during multisampling. + + + When multisampling a texture, the number of quality levels available for an adapter is dependent on the texture format used and the number of samples requested. The maximum sample count defined by D3D10_MAX_MULTISAMPLE_SAMPLE_COUNT in d3d10.h is 32. If the returned value of pNumQualityLevels is 0, the format and sample count combination is not supported for the installed adapter. Furthermore, the definition of a quality level is up to each hardware vendor to define, however no facility is provided by Direct3D to help discover this information. Direct3D 10.1 devices are required to support 4x MSAA for all formats except R32G32B32A32 and R32G32B32 formats. + + The texture format. See . + The number of samples during multisampling. + Number of quality levels supported by the adapter. See remarks. + HRESULT ID3D10Device::CheckMultisampleQualityLevels([In] DXGI_FORMAT Format,[In] int SampleCount,[Out] int* pNumQualityLevels) + + + + Get a counter's information. + + void ID3D10Device::CheckCounterInfo([Out] D3D10_COUNTER_INFO* pCounterInfo) + + + + Get the type, name, units of measure, and a description of an existing counter. + + + Length parameters can be NULL, which indicates the application is not interested in the length nor the corresponding string value. When a length parameter is non-NULL and the corresponding string is NULL, the input value of the length parameter is ignored, and the length of the corresponding string (including terminating NULL) will be returned through the length parameter. When length and the corresponding parameter are both non-NULL, the input value of length is checked to ensure there is enough room, and then the length of the string (including terminating NULL character) is passed out through the length parameter. + + Pointer to a counter description (see ). Specifies which counter information is to be retrieved about. + Pointer to the data type of a counter (see ). Specifies the data type of the counter being retrieved. + Pointer to the number of hardware counters that are needed for this counter type to be created. All instances of the same counter type use the same hardware counters. + String to be filled with a brief name for the counter. May be NULL if the application is not interested in the name of the counter. + Length of the string returned to szName. Can be NULL. + Name of the units a counter measures, provided the memory the reference points to has enough room to hold the string. Can be NULL. The returned string will always be in English. + Length of the string returned to szUnits. Can be NULL. + A description of the counter, provided the memory the reference points to has enough room to hold the string. Can be NULL. The returned string will always be in English. + Length of the string returned to szDescription. Can be NULL. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::CheckCounter([In] const D3D10_COUNTER_DESC* pDesc,[Out] D3D10_COUNTER_TYPE* pType,[Out] int* pActiveCounters,[Out, Buffer, Optional] char* szName,[InOut, Optional] int* pNameLength,[Out, Buffer, Optional] char* szUnits,[InOut, Optional] int* pUnitsLength,[Out, Buffer, Optional] char* szDescription,[InOut, Optional] int* pDescriptionLength) + + + + Get the flags used during the call to create the device with . + + A bitfield containing the flags used to create the device. See . + int ID3D10Device::GetCreationFlags() + + + + Give a device access to a shared resource created on a different Direct3d device. + + + To share a resource between two Direct3D 10 devices the resource must have been created with the flag, if it was created using the ID3D10Device interface. If it was created using the IDXGIDevice interface, then the resource is always shared. The REFIID, or GUID, of the interface to the resource can be obtained by using the __uuidof() macro. For example, __uuidof(ID3D10Buffer) will get the GUID of the interface to a buffer resource. When sharing a resource between two Direct3D 10 devices the unique handle of the resource can be obtained by querying the resource for the interface and then calling {{GetSharedHandle}}. + IDXGIResource* pOtherResource(NULL); + hr = pOtherDeviceResource->QueryInterface( __uuidof(IDXGIResource), (void**)&pOtherResource ); + HANDLE sharedHandle; + pOtherResource->GetSharedHandle(&sharedHandle); + + The only resources that can be shared are 2D non-mipmapped textures. To share a resource between a Direct3D 9 device and a Direct3D 10 device the texture must have been created using the pSharedHandle argument of {{CreateTexture}}. The shared Direct3D 9 handle is then passed to OpenSharedResource in the hResource argument. The following code illustrates the method calls involved. + sharedHandle = NULL; // must be set to NULL to create, can use a valid handle here to open in D3D9 + pDevice9->CreateTexture(..., pTex2D_9, &sharedHandle); + ... + pDevice10->OpenSharedResource(sharedHandle, __uuidof(ID3D10Resource), (void**)(&tempResource10)); + tempResource10->QueryInterface(__uuidof(ID3D10Texture2D), (void**)(&pTex2D_10)); + tempResource10->Release(); + // now use pTex2D_10 with pDevice10 + + Textures being shared from D3D9 to D3D10 have the following restrictions. Textures must be 2D Only 1 mip level is allowed Texture must have default usage Texture must be write only MSAA textures are not allowed Bind flags must have SHADER_RESOURCE and RENDER_TARGET set Only R10G10B10A2_UNORM, R16G16B16A16_FLOAT and R8G8B8A8_UNORM formats are allowed If a shared texture is updated on one device must be called on that device. + + A resource handle. See remarks. + The globally unique identifier (GUID) for the resource interface. See remarks. + Address of a reference to the resource we are gaining access to. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device::OpenSharedResource([In] void* hResource,[In] GUID* ReturnedInterface,[Out, Optional] void** ppResource) + + + + Get the flags used during the call to create the device with . + + A bitfield containing the flags used to create the device. See . + int ID3D10Device::GetCreationFlags() + + + Inner interface giving access to InputAssemblerStage methods. + + + Inner interface giving access to VertexShaderStage methods. + + + Inner interface giving access to PixelShaderStage methods. + + + Inner interface giving access to GeometryShaderStage methods. + + + Inner interface giving access to StreamOutputStage methods. + + + Inner interface giving access to RasterizerStage methods. + + + Inner interface giving access to OutputMergerStage methods. + + + + Get the reason why the device was removed. + + HRESULT ID3D10Device::GetDeviceRemovedReason() + + + + Get the exception-mode flags. + + + An exception-mode flag is used to elevate an error condition to a non-continuable exception. + + int ID3D10Device::GetExceptionMode() + + + Inner interface InputAssemblerStage. + ID3D10Device + + + + Binds a single vertex buffer to the input assembler. + + Index of the slot to which to bind the vertex buffer. + A binding for the input vertex buffer. + + + + Binds an array of vertex buffers to the input assembler. + + Index of the first input slot to use for binding. The first vertex buffer is explicitly bound to the start slot; this causes each additional vertex buffer in the array to be implicitly bound to each subsequent input slot. There are 16 input slots. + An array of bindings for input vertex buffers. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Bind an input-layout object to the {{input-assembler stage}}. + + + Input-layout objects describe how vertex buffer data is streamed into the IA pipeline stage. To create an input-layout object, call . The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + A reference to the input-layout object (see ), which describes the input buffers that will be read by the IA stage. + void IASetInputLayout([In, Optional] ID3D10InputLayout* pInputLayout) + + + + Bind an array of {{vertex buffers}} to the {{input-assembler}} stage. + + + For information about creating vertex buffers, see {{Create a Vertex Buffer}}. Calling this method using a buffer that is currently bound for writing (i.e. bound to the {{stream output}} pipeline stage) will effectively bind NULL instead because a buffer cannot be bound as both an input and an output at the same time. The {{Debug Layer}} will generate a warning whenever a resource is prevented from being bound simultaneously as an input and an output, but this will not prevent invalid data from being used by the runtime. The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + The first {{input slot}} for binding. The first vertex buffer is explicitly bound to the start slot; this causes each additional vertex buffer in the array to be implicitly bound to each subsequent input slot. There are 16 input slots. + The number of vertex buffers in the array. The number of buffers (plus the starting slot) cannot exceed the total number of IA-stage input slots. + A reference to an array of vertex buffers (see ). The vertex buffers must have been created with the flag. + Pointer to an array of stride values; one stride value for each buffer in the vertex-buffer array. Each stride is the size (in bytes) of the elements that are to be used from that vertex buffer. + Pointer to an array of offset values; one offset value for each buffer in the vertex-buffer array. Each offset is the number of bytes between the first element of a vertex buffer and the first element that will be used. + void IASetVertexBuffers([In] int StartSlot,[In] int NumBuffers,[In, Buffer] const ID3D10Buffer** ppVertexBuffers,[In, Buffer] const int* pStrides,[In, Buffer] const int* pOffsets) + + + + Bind an {{index buffer}} to the {{input-assembler}} stage. + + + For information about creating index buffers, see {{Create an Index Buffer}}. Calling this method using a buffer that is currently bound for writing (i.e. bound to the {{stream output}} pipeline stage) will effectively bind NULL instead because a buffer cannot be bound as both an input and an output at the same time. The {{Debug Layer}} will generate a warning whenever a resource is prevented from being bound simultaneously as an input and an output, but this will not prevent invalid data from being used by the runtime. The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + A reference to a buffer (see ) that contains indices. The index buffer must have been created with the flag. + Specifies format of the data in the index buffer. The only formats allowed for index buffer data are 16-bit () and 32-bit (DXGI_FORMAT_R32_UINT) integers. + Offset (in bytes) from the start of the index buffer to the first index to use. + void IASetIndexBuffer([In, Optional] ID3D10Buffer* pIndexBuffer,[In] DXGI_FORMAT Format,[In] int Offset) + + + + Bind information about the {{primitive type}}, and data order that describes input data for the {{input assembler}} stage. + + The type of primitive and ordering of the primitive data (see ). + void IASetPrimitiveTopology([In] D3D10_PRIMITIVE_TOPOLOGY Topology) + + + + Get a reference to the input-layout object that is bound to the {{input-assembler stage}}. + + + For information about creating an input-layout object, see {{Creating the Input-Layout Object}}. Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + A reference to the input-layout object (see ), which describes the input buffers that will be read by the IA stage. + void IAGetInputLayout([Out] ID3D10InputLayout** ppInputLayout) + + + + Get the {{vertex buffers}} bound to the {{input-assembler}} stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + The {{input slot}} of the first vertex buffer to get. The first vertex buffer is explicitly bound to the start slot; this causes each additional vertex buffer in the array to be implicitly bound to each subsequent input slot. There are 16 input slots. + The number of vertex buffers to get starting at the offset. The number of buffers (plus the starting slot) cannot exceed the total number of IA-stage input slots. + A reference to an array of vertex buffers returned by the method (see ). + Pointer to an array of stride values returned by the method; one stride value for each buffer in the vertex-buffer array. Each stride value is the size (in bytes) of the elements that are to be used from that vertex buffer. + Pointer to an array of offset values returned by the method; one offset value for each buffer in the vertex-buffer array. Each offset is the number of bytes between the first element of a vertex buffer and the first element that will be used. + void IAGetVertexBuffers([In] int StartSlot,[In] int NumBuffers,[Out, Buffer, Optional] ID3D10Buffer** ppVertexBuffers,[Out, Buffer, Optional] int* pStrides,[Out, Buffer, Optional] int* pOffsets) + + + + Get a reference to the {{index buffer}} that is bound to the {{input-assembler}} stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + A reference to an index buffer returned by the method (see ). + Specifies format of the data in the index buffer (see ). These formats provide the size and type of the data in the buffer. The only formats allowed for index buffer data are 16-bit (DXGI_FORMAT_R16_UINT) and 32-bit (DXGI_FORMAT_R32_UINT) integers. + Offset (in bytes) from the start of the index buffer, to the first index to use. + void IAGetIndexBuffer([Out, Optional] ID3D10Buffer** pIndexBuffer,[Out, Optional] DXGI_FORMAT* Format,[Out, Optional] int* Offset) + + + + Get information about the {{primitive type}}, and data order that describes input data for the {{input assembler}} stage. + + A reference to the type of primitive, and ordering of the primitive data (see ). + void IAGetPrimitiveTopology([Out] D3D10_PRIMITIVE_TOPOLOGY* pTopology) + + + + Common Shader class. Provides a common set of methods for a Shader Stage. + TODO: check if usage of abstract is not introducing an unacceptable overhead... + + Type of the shader + + + + Maximum number of bindable constant buffers to a pipeline stage. + + + + + Maximum number of bindable resources to a pipeline stage. + + + + + Maximum number of bindable samplers to a pipeline stage. + + + + + Initializes a new instance of the class. + + The pointer. + + + + Gets the constant buffers used by the shader stage. + + Index into the device's zero-based array from which to begin retrieving constant buffers. + Number of buffers to retrieve. + An array of constant buffers. + + + + Gets the sampler states used by the shader stage. + + Index into the device's zero-based array from which to begin retrieving samplers. + Number of samplers to retrieve. + An array of sampler states. + + + + Gets the shader resources used by the shader stage. + + Index into the device's zero-based array from which to begin retrieving shader resources. + Number of resources to retrieve. + An array of shader resources. + + + + Sets a single constant buffer to be used by the shader stage. + + Index into the device's zero-based array to which to set the constant buffer. + constant buffer to set + + + + Sets a single sampler to be used by the shader stage. + + Index into the device's zero-based array to which to set the sampler. + sampler state to set + + + + Sets a single shader resource to be used by the shader stage. + + Index into the device's zero-based array to which to set the resource. + Resource view to attach + + + + Get the shader resources. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + The number of resources to get from the device. Up to a maximum of 128 slots are available for shader resources (ranges from 0 to D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to be returned by the device. + void PSGetShaderResources([In] UINT StartSlot,[In] UINT NumViews,[Out, Buffer] ID3D10ShaderResourceView** ppShaderResourceViews) + + + + Get an array of sampler states from the shader pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into a zero-based array to begin getting samplers from (ranges from 0 to D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers to get from a device context. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Arry of sampler-state interface pointers (see ) to be returned by the device. + void PSGetSamplers([In] UINT StartSlot,[In] UINT NumSamplers,[Out, Buffer] ID3D10SamplerState** ppSamplers) + + + + Get the constant buffers used by the shader pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to retrieve (ranges from 0 to D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffer interface pointers (see ) to be returned by the method. + void PSGetConstantBuffers([In] UINT StartSlot,[In] UINT NumBuffers,[Out, Buffer] ID3D10Buffer** ppConstantBuffers) + + + + Bind an array of shader resources to the shader stage. + + + If an overlapping resource view is already bound to an output slot, such as a rendertarget, then this API will fill the destination shader resource slot with NULL.For information about creating shader-resource views, see . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources (ranges from 0 to D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to set to the device. + void PSSetShaderResources([In] UINT StartSlot,[In] UINT NumViews,[In, Buffer] const ID3D10ShaderResourceView** ppShaderResourceViews) + + + + Set an array of sampler states to the shader pipeline stage. + + + Any sampler may be set to NULL; this invokes the default state, which is defined to be the following.StateDefault ValueFilterD3D10_FILTER_MIN_MAG_MIP_LINEARAddressUD3D10_TEXTURE_ADDRESS_CLAMPAddressVD3D10_TEXTURE_ADDRESS_CLAMPAddressWD3D10_TEXTURE_ADDRESS_CLAMPMipLODBias0MaxAnisotropy1ComparisonFuncD3D10_COMPARISON_NEVERBorderColor[0]1.0fBorderColor[1]1.0fBorderColor[2]1.0fBorderColor[3]1.0fMinLOD-FLT_MAXMaxLODFLT_MAX The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting samplers to (ranges from 0 to D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Pointer to an array of sampler-state interfaces (see ). See Remarks. + void PSSetSamplers([In] UINT StartSlot,[In] UINT NumSamplers,[In, Buffer] const ID3D10SamplerState** ppSamplers) + + + + Set the constant buffers used by the shader pipeline stage. + + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to set (ranges from 0 to D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffers (see ) being given to the device. + void PSSetConstantBuffers([In] UINT StartSlot,[In] UINT NumBuffers,[In, Buffer] const ID3D10Buffer** ppConstantBuffers) + + + Inner interface StreamOutputStage. + ID3D10Device + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + + Set the target output {{buffers}} for the {{StreamOutput}} stage, which enables/disables the pipeline to stream-out data. + + + Call ID3D10Device::SOSetTargets (before any draw calls) to stream data out; call SOSetTargets with NULL to stop streaming data out. For an example, see Exercise 01 from the GDC 2007 workshop, which sets the stream output rendertargets before calling draw methods in the RenderInstanceToStream function. An offset of -1 will cause the stream output buffer to be appended, continuing after the last location written to the buffer in a previous stream output pass. Calling this method using a buffer that is currently bound for writing will effectively bind NULL instead because a buffer cannot be bound as both an input and an output at the same time. The {{Debug Layer}} will generate a warning whenever a resource is prevented from being bound simultaneously as an input and an output, but this will not prevent invalid data from being used by the runtime. The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + an array of output buffers (see ) to bind to the device. The buffers must have been created with the flag. + void SOSetTargets([In] int NumBuffers,[In, Buffer, Optional] const ID3D10Buffer** ppSOTargets,[In, Buffer, Optional] const int* pOffsets) + + + + Get the target output {{buffers}} for the {{StreamOutput}} stage of the pipeline. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Number of buffers to get. A maximum of four output buffers can be retrieved. + an array of output buffers (see ) to bind to the device. + void SOGetTargets([In] int NumBuffers,[Out, Buffer, Optional] ID3D10Buffer** ppSOTargets,[Out, Buffer, Optional] int* pOffsets) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set the target output {{buffers}} for the {{StreamOutput}} stage, which enables/disables the pipeline to stream-out data. + + + Call ID3D10Device::SOSetTargets (before any draw calls) to stream data out; call SOSetTargets with NULL to stop streaming data out. For an example, see Exercise 01 from the GDC 2007 workshop, which sets the stream output rendertargets before calling draw methods in the RenderInstanceToStream function. An offset of -1 will cause the stream output buffer to be appended, continuing after the last location written to the buffer in a previous stream output pass. Calling this method using a buffer that is currently bound for writing will effectively bind NULL instead because a buffer cannot be bound as both an input and an output at the same time. The {{Debug Layer}} will generate a warning whenever a resource is prevented from being bound simultaneously as an input and an output, but this will not prevent invalid data from being used by the runtime. The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + The number of buffer to bind to the device. A maximum of four output buffers can be set. If less than four are defined by the call, the remaining buffer slots are set to NULL. See Remarks. + The array of output buffers (see ) to bind to the device. The buffers must have been created with the flag. + Array of offsets to the output buffers from ppSOTargets, one offset for each buffer. The offset values must be in bytes. + void SOSetTargets([In] int NumBuffers,[In, Buffer, Optional] const ID3D10Buffer** ppSOTargets,[In, Buffer, Optional] const int* pOffsets) + + + + Get the target output {{buffers}} for the {{StreamOutput}} stage of the pipeline. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Number of buffers to get. A maximum of four output buffers can be retrieved. + An array of output buffers (see ) to be retrieved from the device. + Array of offsets to the output buffers from ppSOTargets, one offset for each buffer. The offset values are in bytes. + void SOGetTargets([In] int NumBuffers,[Out, Buffer, Optional] ID3D10Buffer** ppSOTargets,[Out, Buffer, Optional] int* pOffsets) + + + Inner interface OutputMergerStage. + ID3D10Device + + + + Get references to the render targets that are available to the {{output-merger stage}}. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + a depth-stencil view (see ) to be filled with the depth-stencil information from the device. + void OMGetRenderTargets([In] int NumViews,[Out, Buffer, Optional] ID3D10RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D10DepthStencilView** ppDepthStencilView) + + + + Get references to the render targets that are available to the {{output-merger stage}}. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Number of render targets to retrieve. + an array of render targets views (see ) to be filled with the render targets from the device. + void OMGetRenderTargets([In] int NumViews,[Out, Buffer, Optional] ID3D10RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D10DepthStencilView** ppDepthStencilView) + + + + Get references to the render targets and the depth-stencil buffer that are available to the {{output-merger stage}}. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Number of render targets to retrieve. + Pointer to a depth-stencil view (see ) to be filled with the depth-stencil information from the device. + an array of render targets views (see ) to be filled with the render targets from the device. + void OMGetRenderTargets([In] int NumViews,[Out, Buffer, Optional] ID3D10RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D10DepthStencilView** ppDepthStencilView) + + + + Get the {{blend state}} of the output-merger stage. + + + The reference count of the returned interface will be incremented by one when the blend state is retrieved. Applications must release returned reference(s) when they are no longer needed, or else there will be a memory leak. + + Array of blend factors, one for each RGBA component. + Pointer to a {{sample mask}}. + a reference to a blend-state interface (see ). + void OMGetBlendState([Out, Optional] ID3D10BlendState** ppBlendState,[Out, Optional] float BlendFactor[4],[Out, Optional] int* pSampleMask) + + + + Gets the {{depth-stencil}} state of the output-merger stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Pointer to the stencil reference value used in the {{depth-stencil}} test. + a reference to a depth-stencil state interface (see ) to be filled with information from the device. + void OMGetDepthStencilState([Out, Optional] ID3D10DepthStencilState** ppDepthStencilState,[Out, Optional] int* pStencilRef) + + + + Binds a set of render targets to the output-merger stage. + + A set of render target views to bind. + + + + Binds a single render target to the output-merger stage. + + A view of the render target to bind. + + + + Binds a depth-stencil buffer and a set of render targets to the output-merger stage. + + A view of the depth-stencil buffer to bind. + A set of render target views to bind. + + + + Binds a depth-stencil buffer and a single render target to the output-merger stage. + + A view of the depth-stencil buffer to bind. + A view of the render target to bind. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Bind one or more render targets and the depth-stencil buffer to the {{output-merger stage}}. + + + A call to OMSetRenderTargets overrides all bounded render targets and the depth stencil target regardless of the number of render targets in ppRenderTargetViews. The maximum number of render targets a device can have active at any given time is set by a #define in D3D10.h called D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT. It is invalid to try to set the same {{subresource}} to multiple render target slots. If any subresources are also currently bound for reading or writing (perhaps in a different part of the {{pipeline}}), those bind points will be NULL'ed out to prevent the same subresource from being read and written simultaneously in a single rendering operation. The method will not hold references to the interfaces passed in. For that reason, applications should be careful not to release interfaces currently in use by the device. See {{Binding Resources and Pipeline stages}} for more information on binding resources. + + Number of render targets to bind. + Pointer to an array of render targets (see ) to bind to the device. If this parameter is NULL, no render targets are bound. See Remarks. + Pointer to a depth-stencil view (see ) to bind to the device. If this parameter is NULL, the depth-stencil state is not bound. + void OMSetRenderTargets([In] int NumViews,[In, Buffer, Optional] const ID3D10RenderTargetView** ppRenderTargetViews,[In, Optional] ID3D10DepthStencilView* pDepthStencilView) + + + + Set the {{blend state}} of the output-merger stage. + + + Blend state is used by the {{output-merger}} stage to determine how to blend together two pixel values. The two values are commonly the current pixel value and the pixel value already in the output render target. Use the {{blend operation}} to control where the two pixel values come from and how they are mathematically combined. To create a blend-state interface, call . Passing in NULL for the blend-state interface indicates to the runtime to set a default blending state. The following table indicates the default blending parameters. StateDefault Value AlphaToCoverageEnableFALSE BlendEnableFALSE[8] SrcBlendD3D10_BLEND_ONE DstBlendD3D10_BLEND_ZERO BlendOpD3D10_BLEND_OP_ADD SrcBlendAlphaD3D10_BLEND_ONE DstBlendAlphaD3D10_BLEND_ZERO BlendOpAlphaD3D10_BLEND_OP_ADD RenderTargetWriteMask[8]D3D10_COLOR_WRITE_ENABLE_ALL[8] ? A sample mask determines which samples get updated in all the active render targets. The mapping of bits in a sample mask to samples in a multisample render target is the responsibility of an individual application. A sample mask is always applied; it is independent of whether multisampling is enabled, and does not depend on whether an application uses multisample render targets. The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + Pointer to a blend-state interface (see ). Passing in NULL implies a default blend state. See remarks for further details. + Array of blend factors, one for each RGBA component. This requires a blend state object that specifies the option. + 32-bit sample coverage. The default value is 0xffffffff. See remarks. + void OMSetBlendState([In, Optional] ID3D10BlendState* pBlendState,[In] const SHARPDX_COLOR4* BlendFactor,[In] int SampleMask) + + + + Sets the {{depth-stencil}} state of the output-merger stage. + + + To create a depth-stencil state interface, call . Depth-stencil state is used by the {{output-merger}} stage to setup depth-stencil testing. The stencil reference value is the control value used in the depth-stencil test. The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + Pointer to a depth-stencil state interface (see ) to bind to the device. + Reference value to perform against when doing a depth-stencil test. See remarks. + void OMSetDepthStencilState([In, Optional] ID3D10DepthStencilState* pDepthStencilState,[In] int StencilRef) + + + + Get references to the render targets and the depth-stencil buffer that are available to the {{output-merger stage}}. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Number of render targets to retrieve. + Pointer to an array of render targets views (see ) to be filled with the render targets from the device. Specify NULL for this parameter when retrieval of a render target is not needed. + Pointer to a depth-stencil view (see ) to be filled with the depth-stencil information from the device. Specify NULL for this parameter when retrieval of the depth-stencil view is not needed. + void OMGetRenderTargets([In] int NumViews,[Out, Buffer, Optional] ID3D10RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D10DepthStencilView** ppDepthStencilView) + + + + Get the {{blend state}} of the output-merger stage. + + + The reference count of the returned interface will be incremented by one when the blend state is retrieved. Applications must release returned reference(s) when they are no longer needed, or else there will be a memory leak. + + Address of a reference to a blend-state interface (see ). + Array of blend factors, one for each RGBA component. + Pointer to a {{sample mask}}. + void OMGetBlendState([Out, Optional] ID3D10BlendState** ppBlendState,[Out, Optional] SHARPDX_COLOR4* BlendFactor,[Out, Optional] int* pSampleMask) + + + + Gets the {{depth-stencil}} state of the output-merger stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Address of a reference to a depth-stencil state interface (see ) to be filled with information from the device. + Pointer to the stencil reference value used in the {{depth-stencil}} test. + void OMGetDepthStencilState([Out, Optional] ID3D10DepthStencilState** ppDepthStencilState,[Out, Optional] int* pStencilRef) + + + + Gets or sets the blend factor. + + The blend factor. + + + + Gets or sets the blend sample mask. + + The blend sample mask. + + + + Gets or sets the state of the blend. + + The state of the blend. + + + + Gets or sets the depth stencil reference. + + The depth stencil reference. + + + + Gets or sets the state of the depth stencil. + + The state of the depth stencil. + + + Inner interface RasterizerStage. + ID3D10Device + + + + Get the array of {{viewports}} bound to the {{rasterizer stage}} + + An array of viewports (see ). + void RSGetViewports([InOut] int* NumViewports,[Out, Buffer, Optional] D3D10_VIEWPORT* pViewports) + + + + Get the array of {{viewports}} bound to the {{rasterizer stage}} + + An array of viewports (see ). + void RSGetViewports([InOut] int* NumViewports,[Out, Buffer, Optional] D3D10_VIEWPORT* pViewports) + + + + Get the array of {{scissor rectangles}} bound to the {{rasterizer stage}}. + + An array of scissor rectangles (see ). + void RSGetScissorRects([InOut] int* NumRects,[Out, Buffer, Optional] D3D10_RECT* pRects) + + + + Get the array of {{scissor rectangles}} bound to the {{rasterizer stage}}. + + An array of scissor rectangles (see ). + void RSGetScissorRects([InOut] int* NumRects,[Out, Buffer, Optional] D3D10_RECT* pRects) + + + + Binds a single scissor rectangle to the rasterizer stage. + + The scissor rectangle to bind. + + + + Binds a set of scissor rectangles to the rasterizer stage. + + The set of scissor rectangles to bind. + + + + Binds a set of viewports to the rasterizer stage. + + The set of viewports to bind. + + + + Binds a single viewport to the rasterizer stage. + + The viewport to bind. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set the {{rasterizer state}} for the {{rasterizer stage}} of the pipeline. + + + To create a rasterizer state interface, call . For more details on setting up the rasterizer state, see {{Set Rasterizer State}}. The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + Pointer to a rasterizer-state interface (see ) to bind to the pipeline. + void RSSetState([In, Optional] ID3D10RasterizerState* pRasterizerState) + + + + Bind an array of {{viewports}} to the {{rasterizer stage}} of the pipeline. + + + All viewports must be set atomically as one operation. Any viewports not defined by the call are disabled. Which viewport to use is determined by the SV_ViewportArrayIndex semantic output by a geometry shader (see {{shader semantic syntax}}). If a geometry shader does not make use of the SV_ViewportArrayIndex semantic then Direct3D will use the first viewport in the array. + + Number of viewports to bind. + An array of viewports (see ) to bind to the device. Each viewport must have its extents within the allowed ranges: D3D10_VIEWPORT_BOUNDS_MIN, D3D10_VIEWPORT_BOUNDS_MAX, D3D10_MIN_DEPTH, and D3D10_MAX_DEPTH. + void RSSetViewports([In] int NumViewports,[In, Buffer, Optional] const D3D10_VIEWPORT* pViewports) + + + + Bind an array of {{scissor rectangles}} to the {{rasterizer stage}}. + + + The scissor rectangles will only be used if ScissorEnable is set to true in the rasterizer state (see ). Which scissor rectangle to use is determined by the SV_ViewportArrayIndex semantic output by a geometry shader (see {{shader semantic syntax}}). If a geometry shader does not make use of the SV_ViewportArrayIndex semantic then Direct3D will use the first scissor rectangle in the array. Each scissor rectangle in the array corresponds to a viewport in an array of viewports (see ). + + Number of scissor rectangles to bind. + An array of scissor rectangles (see ). + void RSSetScissorRects([In] int NumRects,[In, Buffer, Optional] const D3D10_RECT* pRects) + + + + Get the {{rasterizer state}} from the {{rasterizer stage}} of the pipeline. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Address of a reference to a rasterizer-state interface (see ) to fill with information from the device. + void RSGetState([Out] ID3D10RasterizerState** ppRasterizerState) + + + + Get the array of {{viewports}} bound to the {{rasterizer stage}} + + Number of viewports in pViewports. If pViewports is NULL, this will be filled with the number of viewports currently bound. + An array of viewports (see ) to be filled with information from the device. If NumViewports is greater than the actual number of viewports currently bound, then unused members of the array will contain 0. + void RSGetViewports([InOut] int* NumViewports,[Out, Buffer, Optional] D3D10_VIEWPORT* pViewports) + + + + Get the array of {{scissor rectangles}} bound to the {{rasterizer stage}}. + + Number of scissor rectangles to get. If pRects is NULL, this will be filled with the number of scissor rectangles currently bound. + An array of scissor rectangles (see ). If NumRects is greater than the number of scissor rects currently bound, then unused members of the array will contain 0. + void RSGetScissorRects([InOut] int* NumRects,[Out, Buffer, Optional] D3D10_RECT* pRects) + + + + Get the {{rasterizer state}} from the {{rasterizer stage}} of the pipeline. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + void RSGetState([Out] ID3D10RasterizerState** ppRasterizerState) + + + Inner interface VertexShaderStage. + ID3D10Device + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set the {{constant buffers}} used by the {{vertex shader}} pipeline stage. + + + The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + Index into the device's zero-based array to begin setting constant buffers to. + Number of buffers to set. + Array of constant buffers (see ) being given to the device. + void VSSetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[In, Buffer] const ID3D10Buffer** ppConstantBuffers) + + + + Set a vertex shader to the device. + + + The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + Pointer to a vertex shader (see ). Passing in NULL disables the shader for this pipeline stage. + void VSSetShader([In, Optional] ID3D10VertexShader* pVertexShader) + + + + Bind an array of shader resources to the {{vertex shader stage}}. + + + If you bind a subresource as an input and an output, this API will fill the destination shader resource slot with NULL. The debug layer (when active) will alert you if this is true. For information about creating shader-resource views, see . The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + Index into the device's zero-based array to begin setting shader resources to. + Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources. + Array of {{shader resource view}} interfaces to set to the device. + void VSSetShaderResources([In] int StartSlot,[In] int NumViews,[In, Buffer] const ID3D10ShaderResourceView** ppShaderResourceViews) + + + + Set an array of sampler states to the {{vertex shader}} pipeline stage. + + + Any sampler may be set to NULL; this invokes the default state, which is defined to be the following. + //Default sampler state: + D3D10_SAMPLER_DESC SamplerDesc; + SamplerDesc.Filter = D3D10_FILTER_MIN_MAG_MIP_LINEAR; + SamplerDesc.AddressU = D3D10_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.AddressV = D3D10_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.AddressW = D3D10_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.MipLODBias = 0; + SamplerDesc.MaxAnisotropy = 1; + SamplerDesc.ComparisonFunc = D3D10_COMPARISON_NEVER; + SamplerDesc.BorderColor[0] = 1.0f; + SamplerDesc.BorderColor[1] = 1.0f; + SamplerDesc.BorderColor[2] = 1.0f; + SamplerDesc.BorderColor[3] = 1.0f; + SamplerDesc.MinLOD = -FLT_MAX; + SamplerDesc.MaxLOD = FLT_MAX; + + The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + Index into the device's zero-based array to begin setting samplers to. + Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available. + Pointer to an array of sampler-state interfaces (see ). See Remarks. + void VSSetSamplers([In] int StartSlot,[In] int NumSamplers,[In, Buffer] const ID3D10SamplerState** ppSamplers) + + + + Get the {{constant buffers}} used by the {{vertex shader}} pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin retrieving constant buffers from. + Number of buffers to retrieve. + Array of constant buffer interface references (see ) to be returned by the method. + void VSGetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[Out, Buffer] ID3D10Buffer** ppConstantBuffers) + + + + Get the vertex shader currently set on the device. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Address of a reference to a vertex shader (see ) to be returned by the method. + void VSGetShader([Out] ID3D10VertexShader** ppVertexShader) + + + + Get the vertex shader resources. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin getting shader resources from. + The number of resources to get from the device. Up to a maximum of 128 slots are available for shader resources. + Array of {{shader resource view}} interfaces to be returned by the device. + void VSGetShaderResources([In] int StartSlot,[In] int NumViews,[Out, Buffer] ID3D10ShaderResourceView** ppShaderResourceViews) + + + + Get an array of sampler states from the {{vertex shader}} pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin getting samplers from. + Number of samplers to get from the device. Each pipeline stage has a total of 16 sampler slots available. + Arry of sampler-state interface references (see ) to be returned by the device. + void VSGetSamplers([In] int StartSlot,[In] int NumSamplers,[Out, Buffer] ID3D10SamplerState** ppSamplers) + + + Inner interface PixelShaderStage. + ID3D10Device + + + + Initializes a new instance of the class. + + The native pointer. + + + + Bind an array of shader resources to the {{pixel shader stage}}. + + + If you bind a subresource as an input and an output, this API will fill the destination shader resource slot with NULL. The debug layer (when active) will alert you if this is true. For information about creating shader-resource views, see . The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + Index into the device's zero-based array to begin setting shader resources to. + Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources. + Array of {{shader resource view}} interfaces to set to the device. + void PSSetShaderResources([In] int StartSlot,[In] int NumViews,[In, Buffer] const ID3D10ShaderResourceView** ppShaderResourceViews) + + + + Sets a pixel shader to the device. + + + The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + Pointer to a pixel shader (see ). Passing in NULL disables the shader for this pipeline stage. + void PSSetShader([In, Optional] ID3D10PixelShader* pPixelShader) + + + + Set an array of sampler states to the {{pixel shader}} pipeline stage. + + + Any sampler may be set to NULL; this invokes the default state, which is defined to be the following. StateDefault Value FilterD3D10_FILTER_MIN_MAG_MIP_LINEAR AddressUD3D10_TEXTURE_ADDRESS_CLAMP AddressVD3D10_TEXTURE_ADDRESS_CLAMP AddressWD3D10_TEXTURE_ADDRESS_CLAMP MipLODBias0 MaxAnisotropy1 ComparisonFuncD3D10_COMPARISON_NEVER BorderColor[0]1.0f BorderColor[1]1.0f BorderColor[2]1.0f BorderColor[3]1.0f MinLOD-FLT_MAX MaxLODFLT_MAX ? The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + Index into the device's zero-based array to begin setting samplers to. + Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available. + Pointer to an array of sampler-state interfaces (see ). See Remarks. + void PSSetSamplers([In] int StartSlot,[In] int NumSamplers,[In, Buffer] const ID3D10SamplerState** ppSamplers) + + + + Set the {{constant buffers}} used by the {{pixel shader}} pipeline stage. + + + The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + Index into the device's zero-based array to begin setting constant buffers to. + Number of buffers to set. + Array of constant buffers (see ) being given to the device. + void PSSetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[In, Buffer] const ID3D10Buffer** ppConstantBuffers) + + + + Get the pixel shader resources. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin getting shader resources from. + The number of resources to get from the device. Up to a maximum of 128 slots are available for shader resources. + Array of {{shader resource view}} interfaces to be returned by the device. + void PSGetShaderResources([In] int StartSlot,[In] int NumViews,[Out, Buffer] ID3D10ShaderResourceView** ppShaderResourceViews) + + + + Get the pixel shader currently set on the device. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Address of a reference to a pixel shader (see ) to be returned by the method. + void PSGetShader([Out] ID3D10PixelShader** ppPixelShader) + + + + Get an array of sampler states from the {{pixel shader}} pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin getting samplers from. + Number of samplers to get from the device. Each pipeline stage has a total of 16 sampler slots available. + Arry of sampler-state interface references (see ) to be returned by the device. + void PSGetSamplers([In] int StartSlot,[In] int NumSamplers,[Out, Buffer] ID3D10SamplerState** ppSamplers) + + + + Get the {{constant buffers}} used by the {{pixel shader}} pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin retrieving constant buffers from. + Number of buffers to retrieve. + Array of constant buffer interface references (see ) to be returned by the method. + void PSGetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[Out, Buffer] ID3D10Buffer** ppConstantBuffers) + + + Inner interface GeometryShaderStage. + ID3D10Device + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set the {{constant buffers}} used by the {{geometry shader}} pipeline stage. + + + The method will not hold references to the interfaces passed in. For that reason, applications should be careful not to release interfaces currently in use by the device. + + Index into the device's zero-based array to begin setting constant buffers to. + Number of buffers to set. + Array of constant buffers (see ) being given to the device. + void GSSetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[In, Buffer] const ID3D10Buffer** ppConstantBuffers) + + + + Set a geometry shader to the device. + + + The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + Pointer to a geometry shader (see ). Passing in NULL disables the shader for this pipeline stage. + void GSSetShader([In, Optional] ID3D10GeometryShader* pShader) + + + + Bind an array of shader resources to the {{geometry shader stage}}. + + + If you bind a subresource as an input and an output, this API will fill the destination shader resource slot with NULL. The debug layer (when active) will alert you if this is true. For information about creating shader-resource views, see . The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + Index into the device's zero-based array to begin setting shader resources to. + Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources. + Array of {{shader resource view}} interfaces to set to the device. + void GSSetShaderResources([In] int StartSlot,[In] int NumViews,[In, Buffer] const ID3D10ShaderResourceView** ppShaderResourceViews) + + + + Set an array of sampler states to the {{geometry shader}} pipeline stage. + + + Any sampler may be set to NULL; this invokes the default state, which is defined to be the following. + //Default sampler state: + D3D10_SAMPLER_DESC SamplerDesc; + SamplerDesc.Filter = D3D10_FILTER_MIN_MAG_MIP_LINEAR; + SamplerDesc.AddressU = D3D10_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.AddressV = D3D10_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.AddressW = D3D10_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.MipLODBias = 0; + SamplerDesc.MaxAnisotropy = 1; + SamplerDesc.ComparisonFunc = D3D10_COMPARISON_NEVER; + SamplerDesc.BorderColor[0] = 1.0f; + SamplerDesc.BorderColor[1] = 1.0f; + SamplerDesc.BorderColor[2] = 1.0f; + SamplerDesc.BorderColor[3] = 1.0f; + SamplerDesc.MinLOD = -FLT_MAX; + SamplerDesc.MaxLOD = FLT_MAX; + + The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + Index into the device's zero-based array to begin setting samplers to. + Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available. + Pointer to an array of sampler-state interfaces (see ). See Remarks. + void GSSetSamplers([In] int StartSlot,[In] int NumSamplers,[In, Buffer] const ID3D10SamplerState** ppSamplers) + + + + Get the {{constant buffers}} used by the {{geometry shader}} pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin retrieving constant buffers from. + Number of buffers to retrieve. + Array of constant buffer interface references (see ) to be returned by the method. + void GSGetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[Out, Buffer] ID3D10Buffer** ppConstantBuffers) + + + + Get the geometry shader currently set on the device. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Address of a reference to a geometry shader (see ) to be returned by the method. + void GSGetShader([Out] ID3D10GeometryShader** ppGeometryShader) + + + + Get the geometry shader resources. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin getting shader resources from. + The number of resources to get from the device. Up to a maximum of 128 slots are available for shader resources. + Array of {{shader resource view}} interfaces to be returned by the device. + void GSGetShaderResources([In] int StartSlot,[In] int NumViews,[Out, Buffer] ID3D10ShaderResourceView** ppShaderResourceViews) + + + + Get an array of sampler states from the {{geometry shader}} pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin getting samplers from. + Number of samplers to get from the device. Each pipeline stage has a total of 16 sampler slots available. + Arry of sampler-state references (see ) to be returned by the device. + void GSGetSamplers([In] int StartSlot,[In] int NumSamplers,[Out, Buffer] ID3D10SamplerState** ppSamplers) + + + + This interface encapsulates methods for measuring GPU performance. + + ID3D10Counter + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The counter description. + The newly created object. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a counter description. + + Pointer to a counter description (see ). + void ID3D10Counter::GetDesc([Out] D3D10_COUNTER_DESC* pDesc) + + + + Get a counter description. + + void ID3D10Counter::GetDesc([Out] D3D10_COUNTER_DESC* pDesc) + + + + Counter metadata that contains the type, name, units of measure, and a description of an existing counter. + + + + + Gets the data type of a counter (see ). + + The type. + + + + Gets the number of hardware counters that are needed for this counter type to be created. All instances of the same counter type use the same hardware counters. + + The hardware counter count. + + + + Gets a brief name for the counter. + + The name. + + + + Gets the units a counter measures. + + The units. + + + + Gets a description of the counter. + + The description. + + + + A debug interface controls debug settings, validates pipeline state and can only be used if the {{debug layer}} is turned on. + + ID3D10Debug + + + + Initializes a new instance of the class. + + The device. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set a bitfield of flags that will turn debug features on and off. + + + Setting a feature-mask flag will cause a rendering-operation method (listed below) to do some extra task when called. The possible feature flags are: D3D10_DEBUG_FEATURE_FINISH_PER_RENDER_OPApplication will wait for the GPU to finish processing the rendering operation before continuing. D3D10_DEBUG_FEATURE_FLUSH_PER_RENDER_OPRuntime will additionally call . D3D10_DEBUG_FEATURE_PRESENT_PER_RENDER_OPRuntime will call {{Present}}. Presentation of render buffers will occur according to the settings established by prior calls to and . ? These feature-mask flags apply to the following rendering-operation methods: + + Feature-mask flags bitwise ORed together. If a flag is present, then that feature will be set to on, otherwise the feature will be set to off. See remarks for a list of flags. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Debug::SetFeatureMask([None] int Mask) + + + + Get a bitfield of flags that indicates which debug features are on or off. + + Mask of feature-mask flags bitwise ORed together. If a flag is present, then that feature will be set to on, otherwise the feature will be set to off. See for a list of possible feature-mask flags. + int ID3D10Debug::GetFeatureMask() + + + + Set the number of milliseconds to sleep after {{Present}} is called. + + + The application will only sleep if D3D10_DEBUG_FEATURE_PRESENT_PER_RENDER_OP is a set in the {{feature mask}}. If that flag is not set the number of milliseconds is set but ignored and the application does not sleep. 10ms is used as a default value if this method is never called. + + Number of milliseconds to sleep after Present is called. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Debug::SetPresentPerRenderOpDelay([None] int Milliseconds) + + + + Get the number of milliseconds to sleep after {{Present}} is called. + + + Value is set with . + + Number of milliseconds to sleep after Present is called. + int ID3D10Debug::GetPresentPerRenderOpDelay() + + + + Set a swap chain that the runtime will use for automatically calling {{Present}}. + + + The swap chain set by this method will only be used if D3D10_DEBUG_FEATURE_PRESENT_PER_RENDER_OP is set in the {{feature mask}}. + + Swap chain that the runtime will use for automatically calling {{Present}}; must have been created with the swap-effect flag. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Debug::SetSwapChain([In, Optional] IDXGISwapChain* pSwapChain) + + + + Get the swap chain that the runtime will use for automatically calling {{Present}}. + + + The swap chain retrieved by this method will only be used if D3D10_DEBUG_FEATURE_PRESENT_PER_RENDER_OP is set in the {{feature mask}}. + + Swap chain that the runtime will use for automatically calling {{Present}}. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Debug::GetSwapChain([Out] IDXGISwapChain** ppSwapChain) + + + + Check the validity of pipeline state. + + + When the {{debug layer}} is turned on all draw functions will do this operation. + + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Debug::Validate() + + + + Gets or sets the feature flags that indicates which debug features are on or off. + + The feature flags. + + + + Get the number of milliseconds to sleep after {{Present}} is called. + + + Value is set with . + + int ID3D10Debug::GetPresentPerRenderOpDelay() + + + + Get the swap chain that the runtime will use for automatically calling {{Present}}. + + + The swap chain retrieved by this method will only be used if D3D10_DEBUG_FEATURE_PRESENT_PER_RENDER_OP is set in the {{feature mask}}. + + HRESULT ID3D10Debug::GetSwapChain([Out] IDXGISwapChain** ppSwapChain) + + + + A depth-stencil-state interface accesses depth-stencil state which sets up the {{depth-stencil test}} for the output-merger stage. + + ID3D10DepthStencilState + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the depth-stencil state. + + A reference to the depth-stencil state (see ). + void ID3D10DepthStencilState::GetDesc([Out] D3D10_DEPTH_STENCIL_DESC* pDesc) + + + + Get the depth-stencil state. + + void ID3D10DepthStencilState::GetDesc([Out] D3D10_DEPTH_STENCIL_DESC* pDesc) + + + + A {{depth-stencil-view}} interface accesses a texture resource during {{depth-stencil testing}}. + + ID3D10DepthStencilView + + + + A view interface specifies the parts of a resource the pipeline can access during rendering (see {{view}}). + + ID3D10View + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the resource that is accessed through this view. + + + This function increments the reference count of the resource by one, so it is necessary to call Release on the returned reference when the application is done with it. Destroying (or losing) the returned reference before Release is called will result in a memory leak. + + Address of a reference to the resource that is accessed through this view. (See .) + void ID3D10View::GetResource([Out] ID3D10Resource** ppResource) + + + + Get the resource that is accessed through this view. + + + This function increments the reference count of the resource by one, so it is necessary to call Release on the returned reference when the application is done with it. Destroying (or losing) the returned reference before Release is called will result in a memory leak. + + void ID3D10View::GetResource([Out] ID3D10Resource** ppResource) + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the DepthStencil flag. + ID3D10Device::CreateDepthStencilView + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the DepthStencil flag. + A structure describing the to be created. + ID3D10Device::CreateDepthStencilView + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the depth-stencil {{view}}. + + Pointer to a depth-stencil-view description (see ). + void ID3D10DepthStencilView::GetDesc([Out] D3D10_DEPTH_STENCIL_VIEW_DESC* pDesc) + + + + Get the depth-stencil {{view}}. + + void ID3D10DepthStencilView::GetDesc([Out] D3D10_DEPTH_STENCIL_VIEW_DESC* pDesc) + + + + The device interface represents a virtual adapter for Direct3D 10.1; it is used to perform rendering and create Direct3D resources. + + ID3D10Device1 + + + + Constructor for a D3D10.1 Device. See for more information. + + + + + + Constructor for a D3D10.1 Device. See for more information. + + + + + + Constructor for a D3D10.1 Device. See for more information. + + + + + + + Constructor for a D3D10.1 Device. See for more information. + + + + + + + Constructor for a D3D10.1 Device. See for more information. + + + + + + + + Constructor for a D3D10.1 Device. See for more information. + + + + + + + + Initializes a new instance of the class along with a new used for rendering. + + The type of device to create. + A list of runtime layers to enable. + Details used to create the swap chain. + When the method completes, contains the created device instance. + When the method completes, contains the created swap chain instance. + A object describing the result of the operation. + + + + Initializes a new instance of the class along with a new used for rendering. + + The video adapter on which the device should be created. + A list of runtime layers to enable. + Details used to create the swap chain. + When the method completes, contains the created device instance. + When the method completes, contains the created swap chain instance. + A object describing the result of the operation. + + + + Initializes a new instance of the class along with a new used for rendering. + + The type of device to create. + A list of runtime layers to enable. + Details used to create the swap chain. + Desired feature level + When the method completes, contains the created device instance. + When the method completes, contains the created swap chain instance. + A object describing the result of the operation. + + + + Initializes a new instance of the class along with a new used for rendering. + + The video adapter on which the device should be created. + A list of runtime layers to enable. + Details used to create the swap chain. + Desired feature level + When the method completes, contains the created device instance. + When the method completes, contains the created swap chain instance. + A object describing the result of the operation. + + + + This overload has been deprecated. Use one of the alternatives that does not take both an adapter and a driver type. + + + + + Initializes a new instance of the class. + + The native pointer. + + + + Create a shader-resource {{view}} for accessing data in a resource. + + + A resource is made up of one or more {{subresources}}, a view identifies which subresources to allow the pipeline to access. In addition, each resource is bound to the pipeline using a view. A shader-resource view is designed to bind any buffer or texture resource to the {{shader stages}} using the following API methods: {{VSSetShaderResources}}, {{GSSetShaderResources}} and {{PSSetShaderResources}}. Since a view is fully typed, this means that typeless resources become fully typed when bound to the pipeline. This method requires Windows Vista Service Pack 1. + + Pointer to the {{resource}} that will serve as input to a shader. This resource must have been created with the flag. + Pointer to a shader-resource-view description (see ). Set this parameter to NULL to create a view that accesses the entire resource (using the format the resource was created with). + Address of a reference to a shader-resource view (see ). Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device1::CreateShaderResourceView1([In] ID3D10Resource* pResource,[In, Optional] const D3D10_SHADER_RESOURCE_VIEW_DESC1* pDesc,[Out, Optional] ID3D10ShaderResourceView1** ppSRView) + + + + Create a blend-state object that encapsules blend state for the output-merger stage. + + + An application can create up to 4096 unique blend-state objects. For each object created, the runtime checks to see if a previous object has the same state. If such a previous object exists, the runtime will return a reference to previous instance instead of creating a duplicate object. This method requires Windows Vista Service Pack 1. + + Pointer to a blend-state description (see ). + Address of a reference to the blend-state object created (see ). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Device1::CreateBlendState1([In] const D3D10_BLEND_DESC1* pBlendStateDesc,[Out, Optional] ID3D10BlendState1** ppBlendState) + + + + Gets the feature level of the hardware device. + + + This method requires Windows Vista Service Pack 1. + + The feature level (see ). + D3D10_FEATURE_LEVEL1 ID3D10Device1::GetFeatureLevel() + + + + Gets the feature level of the hardware device. + + + This method requires Windows Vista Service Pack 1. + + D3D10_FEATURE_LEVEL1 ID3D10Device1::GetFeatureLevel() + + + + An ID3D10Effect interface manages a set of state objects, resources and shaders for implementing a rendering effect. + + ID3D10Effect + + + + Initializes a new instance of the class. + + The device. + The effect byte code. + + + + Initializes a new instance of the class. + + The device. + The effect byte code. + Effect compile options + + + + Initializes a new instance of the class. + + The device. + The effect byte code. + Effect compile options + Optional. A reference to an memory space for effect variables that are shared across effects (see ). + + + + Initializes a new instance of the class. + + The native pointer. + + + + Test an effect to see if it contains valid syntax. + + TRUE if the code syntax is valid; otherwise FALSE. + BOOL ID3D10Effect::IsValid() + + + + Test an effect to see if it is part of a memory pool. + + TRUE if the effect is pooled; otherwise FALSE. See . + BOOL ID3D10Effect::IsPool() + + + + Get the device that created the effect. + + + An effect is created for a specific device, by calling a function such as {{D3DX10CreateEffectFromFile}}. + + A reference to an . + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Effect::GetDevice([Out] ID3D10Device** ppDevice) + + + + Get an effect description. + + + An effect description contains basic information about an effect such as the techniques it contains and the constant buffer resources it requires. + + A reference to an effect description (see ). + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Effect::GetDesc([Out] D3D10_EFFECT_DESC* pDesc) + + + + Get a constant buffer by index. + + + An effect that contains a variable that will be read/written by an application requires at least one constant buffer. For best performance, an effect should organize variables into one or more constant buffers based on their frequency of update. + + A zero-based index. + A reference to a . + ID3D10EffectConstantBuffer* ID3D10Effect::GetConstantBufferByIndex([None] int Index) + + + + Get a constant buffer by name. + + + An effect that contains a variable that will be read/written by an application requires at least one constant buffer. For best performance, an effect should organize variables into one or more constant buffers based on their frequency of update. + + The constant-buffer name. + A reference to the constant buffer indicated by the Name. See . + ID3D10EffectConstantBuffer* ID3D10Effect::GetConstantBufferByName([None] const char* Name) + + + + Get a variable by index. + + + An effect may contain one or more variables. Variables outside of a technique are considered global to all effects, those located inside of a technique are local to that technique. You can access any local non-static effect variable using its name or with an index. The method returns a reference to an {{effect-variable interface}} if a variable is not found; you can call to verify whether or not the index exists. + + A zero-based index. + A reference to a . + ID3D10EffectVariable* ID3D10Effect::GetVariableByIndex([None] int Index) + + + + Get a variable by name. + + + An effect may contain one or more variables. Variables outside of a technique are considered global to all effects, those located inside of a technique are local to that technique. You can access an effect variable using its name or with an index. The method returns a reference to an {{effect-variable interface}} if a variable is not found; you can call to verify whether or not the name exists. + + The variable name. + A reference to an . + ID3D10EffectVariable* ID3D10Effect::GetVariableByName([None] const char* Name) + + + + Get a variable by semantic. + + + Each effect variable can have a semantic attached, which is a user defined metadata string. Some {{system-value semantics}} are reserved words that trigger built in functionality by pipeline stages. The method returns a reference to an {{effect-variable interface}} if a variable is not found; you can call to verify whether or not the semantic exists. + + The semantic name. + A reference to the effect variable indicated by the Semantic. See . + ID3D10EffectVariable* ID3D10Effect::GetVariableBySemantic([None] const char* Semantic) + + + + Get a technique by index. + + + An effect contains one or more techniques; each technique contains one or more passes. You can access a technique using its name or with an index. For more about techniques, see {{techniques and passes}}. + + A zero-based index. + A reference to an . + ID3D10EffectTechnique* ID3D10Effect::GetTechniqueByIndex([None] int Index) + + + + Get a technique by name. + + + An effect contains one or more techniques; each technique contains one or more passes. You can access a technique using its name or with an index. For more about techniques, see {{techniques and passes}}. + + The name of the technique. + A reference to an , or NULL if the technique is not found. + ID3D10EffectTechnique* ID3D10Effect::GetTechniqueByName([None] const char* Name) + + + + Minimize the amount of memory required for an effect. + + + An effect uses memory space two different ways: to store the information required by the runtime to execute an effect, and to store the metadata required to reflect information back to an application using the API. You can minimize the amount of memory required by an effect by calling ID3D10Effect::Optimize which removes the reflection metadata from memory. API methods to read variables will no longer work once reflection data has been removed. The following methods will fail after Optimize has been called on an effect. Note that references retrieved with these methods before calling ID3D10Effect::Optimize are still valid after ID3D10Effect::Optimize is called. This allows the application to get all the variables, techniques, and passes it will use, call Optimize, and then use the effect. + + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10Effect::Optimize() + + + + Test an effect to see if the reflection metadata has been removed from memory. + + + An effect uses memory space two different ways: to store the information required by the runtime to execute an effect, and to store the metadata required to reflect information back to an application using the API. You can minimize the amount of memory required by an effect by calling which removes the reflection metadata from memory. Of course, API methods to read variables will no longer work once reflection data has been removed. + + TRUE if the effect is optimized; otherwise FALSE. + BOOL ID3D10Effect::IsOptimized() + + + + Test an effect to see if it contains valid syntax. + + BOOL ID3D10Effect::IsValid() + + + + Test an effect to see if it is part of a memory pool. + + BOOL ID3D10Effect::IsPool() + + + + Get the device that created the effect. + + + An effect is created for a specific device, by calling a function such as {{D3DX10CreateEffectFromFile}}. + + HRESULT ID3D10Effect::GetDevice([Out] ID3D10Device** ppDevice) + + + + Get an effect description. + + + An effect description contains basic information about an effect such as the techniques it contains and the constant buffer resources it requires. + + HRESULT ID3D10Effect::GetDesc([Out] D3D10_EFFECT_DESC* pDesc) + + + + Test an effect to see if the reflection metadata has been removed from memory. + + + An effect uses memory space two different ways: to store the information required by the runtime to execute an effect, and to store the metadata required to reflect information back to an application using the API. You can minimize the amount of memory required by an effect by calling which removes the reflection metadata from memory. Of course, API methods to read variables will no longer work once reflection data has been removed. + + BOOL ID3D10Effect::IsOptimized() + + + + The blend-variable interface accesses blend state. + + ID3D10EffectBlendVariable + + + + The ID3D10EffectVariable interface is the base class for all effect variables. + + ID3D10EffectVariable + + + + Set data. + + A reference to the variable. + size in bytes of data to write. + + Returns one of the following {{Direct3D 10 Return Codes}}. + + + This method does no conversion or type checking; it is therefore a very quick way to access array items. + + HRESULT ID3D10EffectVariable::SetRawValue([None] void* pData,[None] int Offset,[None] int Count) + + + + Get data. + + + This method does no conversion or type checking; it is therefore a very quick way to access array items. + + The number of bytes to get. + Returns a filled with the value. + HRESULT ID3D10EffectVariable::GetRawValue([None] void* pData,[None] int Offset,[None] int Count) + + + + Get a scalar variable. + + + AsScalar returns a version of the effect variable that has been specialized to a scalar variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain scalar data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a scalar variable. See . + ID3D10EffectScalarVariable* ID3D10EffectVariable::AsScalar() + + + + Get a vector variable. + + + AsVector returns a version of the effect variable that has been specialized to a vector variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain vector data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a vector variable. See . + ID3D10EffectVectorVariable* ID3D10EffectVariable::AsVector() + + + + Get a matrix variable. + + + AsMatrix returns a version of the effect variable that has been specialized to a matrix variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain matrix data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a matrix variable. See . + ID3D10EffectMatrixVariable* ID3D10EffectVariable::AsMatrix() + + + + Get a string variable. + + + AsString returns a version of the effect variable that has been specialized to a string variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain string data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a string variable. See . + ID3D10EffectStringVariable* ID3D10EffectVariable::AsString() + + + + Get a shader-resource variable. + + + AsShaderResource returns a version of the effect variable that has been specialized to a shader-resource variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain shader-resource data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a shader-resource variable. See . + ID3D10EffectShaderResourceVariable* ID3D10EffectVariable::AsShaderResource() + + + + Get a render-target-view variable. + + + This method returns a version of the effect variable that has been specialized to a render-target-view variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain render-target-view data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a render-target-view variable. See . + ID3D10EffectRenderTargetViewVariable* ID3D10EffectVariable::AsRenderTargetView() + + + + Get a depth-stencil-view variable. + + + This method returns a version of the effect variable that has been specialized to a depth-stencil-view variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain depth-stencil-view data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a depth-stencil-view variable. See . + ID3D10EffectDepthStencilViewVariable* ID3D10EffectVariable::AsDepthStencilView() + + + + Get a constant buffer. + + + AsConstantBuffer returns a version of the effect variable that has been specialized to a constant buffer. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain constant buffer data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a constant buffer. See . + ID3D10EffectConstantBuffer* ID3D10EffectVariable::AsConstantBuffer() + + + + Get a shader variable. + + + AsShader returns a version of the effect variable that has been specialized to a shader variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain shader data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a shader variable. See . + ID3D10EffectShaderVariable* ID3D10EffectVariable::AsShader() + + + + Get a effect-blend variable. + + + AsBlend returns a version of the effect variable that has been specialized to an effect-blend variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain effect-blend data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to an effect blend variable. See . + ID3D10EffectBlendVariable* ID3D10EffectVariable::AsBlend() + + + + Get a depth-stencil variable. + + + AsDepthStencil returns a version of the effect variable that has been specialized to a depth-stencil variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain depth-stencil data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a depth-stencil variable. See . + ID3D10EffectDepthStencilVariable* ID3D10EffectVariable::AsDepthStencil() + + + + Get a rasterizer variable. + + + AsRasterizer returns a version of the effect variable that has been specialized to a rasterizer variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain rasterizer data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a rasterizer variable. See . + ID3D10EffectRasterizerVariable* ID3D10EffectVariable::AsRasterizer() + + + + Get a sampler variable. + + + AsSampler returns a version of the effect variable that has been specialized to a sampler variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain sampler data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a sampler variable. See . + ID3D10EffectSamplerVariable* ID3D10EffectVariable::AsSampler() + + + + Initializes a new instance of the class. + + The native pointer. + + + + Compare the data type with the data stored. + + + This method checks that the data type matches the data stored after casting one interface to another (using any of the As methods). + + TRUE if the syntax is valid; otherwise FALSE. + BOOL ID3D10EffectVariable::IsValid() + + + + Get type information. + + A reference to an . + ID3D10EffectType* ID3D10EffectVariable::GetType() + + + + Get a description. + + A reference to an effect-variable description (see ). + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVariable::GetDesc([Out] D3D10_EFFECT_VARIABLE_DESC* pDesc) + + + + Get an annotation by index. + + + Annonations can be attached to a technique, a pass or a gloval variable. For the syntax, see {{Annotation Syntax (Direct3D 10)}}. + + A zero-based index. + A reference to an . + ID3D10EffectVariable* ID3D10EffectVariable::GetAnnotationByIndex([None] int Index) + + + + Get an annotation by name. + + + Annonations can be attached to a technique, a pass or a gloval variable. For the syntax, see {{Annotation Syntax (Direct3D 10)}}. + + The annotation name. + A reference to an . Note that if the annotation is not found the ID3D10EffectVariable Interface returned will be empty. The method should be called to determine whether the annotation was found. + ID3D10EffectVariable* ID3D10EffectVariable::GetAnnotationByName([None] const char* Name) + + + + Get a structure member by index. + + + If the effect variable is an structure, use this method to look up a member by index. + + A zero-based index. + A reference to an . + ID3D10EffectVariable* ID3D10EffectVariable::GetMemberByIndex([None] int Index) + + + + Get a structure member by name. + + + If the effect variable is an structure, use this method to look up a member by name. + + Member name. + A reference to an . + ID3D10EffectVariable* ID3D10EffectVariable::GetMemberByName([None] const char* Name) + + + + Get a structure member by semantic. + + + If the effect variable is an structure, use this method to look up a member by attached semantic. + + The semantic. + A reference to an . + ID3D10EffectVariable* ID3D10EffectVariable::GetMemberBySemantic([None] const char* Semantic) + + + + Get an array element. + + + If the effect variable is an array, use this method to return one of the elements. + + A zero-based index; otherwise 0. + A reference to an . + ID3D10EffectVariable* ID3D10EffectVariable::GetElement([None] int Index) + + + + Get a constant buffer. + + + Effect variables are read-from or written-to a constant buffer. + + A reference to a . + ID3D10EffectConstantBuffer* ID3D10EffectVariable::GetParentConstantBuffer() + + + + Get a scalar variable. + + + AsScalar returns a version of the effect variable that has been specialized to a scalar variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain scalar data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a scalar variable. See . + ID3D10EffectScalarVariable* ID3D10EffectVariable::AsScalar() + + + + Get a vector variable. + + + AsVector returns a version of the effect variable that has been specialized to a vector variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain vector data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a vector variable. See . + ID3D10EffectVectorVariable* ID3D10EffectVariable::AsVector() + + + + Get a matrix variable. + + + AsMatrix returns a version of the effect variable that has been specialized to a matrix variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain matrix data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a matrix variable. See . + ID3D10EffectMatrixVariable* ID3D10EffectVariable::AsMatrix() + + + + Get a string variable. + + + AsString returns a version of the effect variable that has been specialized to a string variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain string data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a string variable. See . + ID3D10EffectStringVariable* ID3D10EffectVariable::AsString() + + + + Get a shader-resource variable. + + + AsShaderResource returns a version of the effect variable that has been specialized to a shader-resource variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain shader-resource data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a shader-resource variable. See . + ID3D10EffectShaderResourceVariable* ID3D10EffectVariable::AsShaderResource() + + + + Get a render-target-view variable. + + + This method returns a version of the effect variable that has been specialized to a render-target-view variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain render-target-view data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a render-target-view variable. See . + ID3D10EffectRenderTargetViewVariable* ID3D10EffectVariable::AsRenderTargetView() + + + + Get a depth-stencil-view variable. + + + This method returns a version of the effect variable that has been specialized to a depth-stencil-view variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain depth-stencil-view data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a depth-stencil-view variable. See . + ID3D10EffectDepthStencilViewVariable* ID3D10EffectVariable::AsDepthStencilView() + + + + Get a constant buffer. + + + AsConstantBuffer returns a version of the effect variable that has been specialized to a constant buffer. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain constant buffer data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a constant buffer. See . + ID3D10EffectConstantBuffer* ID3D10EffectVariable::AsConstantBuffer() + + + + Get a shader variable. + + + AsShader returns a version of the effect variable that has been specialized to a shader variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain shader data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a shader variable. See . + ID3D10EffectShaderVariable* ID3D10EffectVariable::AsShader() + + + + Get a effect-blend variable. + + + AsBlend returns a version of the effect variable that has been specialized to an effect-blend variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain effect-blend data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to an effect blend variable. See . + ID3D10EffectBlendVariable* ID3D10EffectVariable::AsBlend() + + + + Get a depth-stencil variable. + + + AsDepthStencil returns a version of the effect variable that has been specialized to a depth-stencil variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain depth-stencil data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a depth-stencil variable. See . + ID3D10EffectDepthStencilVariable* ID3D10EffectVariable::AsDepthStencil() + + + + Get a rasterizer variable. + + + AsRasterizer returns a version of the effect variable that has been specialized to a rasterizer variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain rasterizer data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a rasterizer variable. See . + ID3D10EffectRasterizerVariable* ID3D10EffectVariable::AsRasterizer() + + + + Get a sampler variable. + + + AsSampler returns a version of the effect variable that has been specialized to a sampler variable. Similar to a cast, this specialization will return an invalid object if the effect variable does not contain sampler data. Applications can test the returned object for validity by calling {{IsValid}}. + + A reference to a sampler variable. See . + ID3D10EffectSamplerVariable* ID3D10EffectVariable::AsSampler() + + + + Set data. + + + This method does no conversion or type checking; it is therefore a very quick way to access array items. + + A reference to the variable. + The offset (in bytes) from the beginning of the reference to the data. + The number of bytes to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVariable::SetRawValue([None] void* pData,[None] int Offset,[None] int Count) + + + + Get data. + + + This method does no conversion or type checking; it is therefore a very quick way to access array items. + + A reference to the variable. + The offset (in bytes) from the beginning of the reference to the data. + The number of bytes to get. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVariable::GetRawValue([None] void* pData,[None] int Offset,[None] int Count) + + + + Compare the data type with the data stored. + + + This method checks that the data type matches the data stored after casting one interface to another (using any of the As methods). + + BOOL ID3D10EffectVariable::IsValid() + + + + Get type information. + + ID3D10EffectType* ID3D10EffectVariable::GetType() + + + + Get a description. + + HRESULT ID3D10EffectVariable::GetDesc([Out] D3D10_EFFECT_VARIABLE_DESC* pDesc) + + + + Get a constant buffer. + + + Effect variables are read-from or written-to a constant buffer. + + ID3D10EffectConstantBuffer* ID3D10EffectVariable::GetParentConstantBuffer() + + + + Get a pointer to a blend-state interface. + + Returns . + HRESULT ID3D10EffectBlendVariable::GetBlendState([None] int Index,[Out] ID3D10BlendState** ppBlendState) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a reference to a blend-state interface. + + Index into an array of blend-state interfaces. If there is only one blend-state interface, use 0. + The address of a reference to a blend-state interface (see ). + HRESULT ID3D10EffectBlendVariable::GetBlendState([None] int Index,[Out] ID3D10BlendState** ppBlendState) + + + + Get a reference to a blend-state variable. + + + Effect variables are saved in memory in the backing store; when a technique is applied, the values in the backing store are copied to the device. Backing store data can used to recreate the variable when necessary. + + Index into an array of blend-state descriptions. If there is only one blend-state variable in the effect, use 0. + A reference to a blend-state description (see ). + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectBlendVariable::GetBackingStore([None] int Index,[Out] D3D10_BLEND_DESC* pBlendDesc) + + + + A depth-stencil-variable interface accesses depth-stencil state. + + ID3D10EffectDepthStencilVariable + + + + Get a pointer to a depth-stencil interface. + + Returns a pointer to a blend-state interface (see ). + HRESULT ID3D10EffectDepthStencilVariable::GetDepthStencilState([None] int Index,[Out] ID3D10DepthStencilState** ppDepthStencilState) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a reference to a depth-stencil interface. + + Index into an array of depth-stencil interfaces. If there is only one depth-stencil interface, use 0. + The address of a reference to a blend-state interface (see ). + HRESULT ID3D10EffectDepthStencilVariable::GetDepthStencilState([None] int Index,[Out] ID3D10DepthStencilState** ppDepthStencilState) + + + + Get a reference to a variable that contains depth-stencil state. + + + Effect variables are saved in memory in the backing store; when a technique is applied, the values in the backing store are copied to the device. Backing store data can used to recreate the variable when necessary. + + Index into an array of depth-stencil-state descriptions. If there is only one depth-stencil variable in the effect, use 0. + A reference to a depth-stencil-state description (see ). + HRESULT ID3D10EffectDepthStencilVariable::GetBackingStore([None] int Index,[Out] D3D10_DEPTH_STENCIL_DESC* pDepthStencilDesc) + + + + A depth-stencil-view-variable interface accesses a depth-stencil view. + + ID3D10EffectDepthStencilViewVariable + + + + Set an array of depth-stencil-view resources. + + A pointer to an array of depth-stencil-view interfaces. See . + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectDepthStencilViewVariable::SetDepthStencilArray([In, Buffer] ID3D10DepthStencilView** ppResources,[None] int Offset,[None] int Count) + + + + Set an array of depth-stencil-view resources. + + A pointer to an array of depth-stencil-view interfaces. See . + The zero-based array index to set the first interface. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectDepthStencilViewVariable::SetDepthStencilArray([In, Buffer] ID3D10DepthStencilView** ppResources,[None] int Offset,[None] int Count) + + + + Get an array of depth-stencil-view resources. + + The number of elements in the array. + Returns an array of depth-stencil-view interfaces. See . + HRESULT ID3D10EffectDepthStencilViewVariable::GetDepthStencilArray([Out, Buffer] ID3D10DepthStencilView** ppResources,[None] int Offset,[None] int Count) + + + + Get an array of depth-stencil-view resources. + + The zero-based array index to get the first interface. + The number of elements in the array. + Returns an array of depth-stencil-view interfaces. See . + HRESULT ID3D10EffectDepthStencilViewVariable::GetDepthStencilArray([Out, Buffer] ID3D10DepthStencilView** ppResources,[None] int Offset,[None] int Count) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set a depth-stencil-view resource. + + A reference to a depth-stencil-view interface. See . + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectDepthStencilViewVariable::SetDepthStencil([None] ID3D10DepthStencilView* pResource) + + + + Get a depth-stencil-view resource. + + The address of a reference to a depth-stencil-view interface. See . + HRESULT ID3D10EffectDepthStencilViewVariable::GetDepthStencil([None] ID3D10DepthStencilView** ppResource) + + + + Set an array of depth-stencil-view resources. + + A reference to an array of depth-stencil-view interfaces. See . + The zero-based array index to set the first interface. + The number of elements in the array. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectDepthStencilViewVariable::SetDepthStencilArray([In, Buffer] ID3D10DepthStencilView** ppResources,[None] int Offset,[None] int Count) + + + + Get an array of depth-stencil-view resources. + + A reference to an array of depth-stencil-view interfaces. See . + The zero-based array index to get the first interface. + The number of elements in the array. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectDepthStencilViewVariable::GetDepthStencilArray([Out, Buffer] ID3D10DepthStencilView** ppResources,[None] int Offset,[None] int Count) + + + + A matrix-variable interface accesses a matrix. + + ID3D10EffectMatrixVariable + + + + Set a floating-point matrix. + + A pointer to the first element in the matrix. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectMatrixVariable::SetMatrix([In] float* pData) + + + + Set an array of floating-point matrices. + + A pointer to the first matrix. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectMatrixVariable::SetMatrixArray([In, Buffer] float* pData,[None] int Offset,[None] int Count) + + + + Set an array of floating-point matrices. + + A pointer to the first matrix. + The number of matrix elements to skip from the start of the array. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectMatrixVariable::SetMatrixArray([In, Buffer] float* pData,[None] int Offset,[None] int Count) + + + + Get an array of matrices. + + The number of matrices in the returned array. + Returns an array of matrix. + HRESULT ID3D10EffectMatrixVariable::GetMatrixArray([Out, Buffer] float* pData,[None] int Offset,[None] int Count) + + + + Get an array of matrices. + + The offset (in number of matrices) between the start of the array and the first matrix returned. + The number of matrices in the returned array. + Returns an array of matrix. + HRESULT ID3D10EffectMatrixVariable::GetMatrixArray([Out, Buffer] float* pData,[None] int Offset,[None] int Count) + + + + Transpose and set a floating-point matrix. + + + Transposing a matrix will rearrange the data order from row-column order to column-row order (or vice versa). + + A pointer to the first element of a matrix. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectMatrixVariable::SetMatrixTranspose([In] float* pData) + + + + Transpose and set an array of floating-point matrices. + + + Transposing a matrix will rearrange the data order from row-column order to column-row order (or vice versa). + + A pointer to an array of matrices. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectMatrixVariable::SetMatrixTransposeArray([In] float* pData,[None] int Offset,[None] int Count) + + + + Transpose and set an array of floating-point matrices. + + + Transposing a matrix will rearrange the data order from row-column order to column-row order (or vice versa). + + A pointer to an array of matrices. + The offset (in number of matrices) between the start of the array and the first matrix to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectMatrixVariable::SetMatrixTransposeArray([In] float* pData,[None] int Offset,[None] int Count) + + + + Transpose and get an array of floating-point matrices. + + + Transposing a matrix will rearrange the data order from row-column order to column-row order (or vice versa). + + The number of matrices in the array to get. + Returns an array of transposed . + HRESULT ID3D10EffectMatrixVariable::GetMatrixTransposeArray([Out, Buffer] float* pData,[None] int Offset,[None] int Count) + + + + Transpose and get an array of floating-point matrices. + + + Transposing a matrix will rearrange the data order from row-column order to column-row order (or vice versa). + + The offset (in number of matrices) between the start of the array and the first matrix to get. + The number of matrices in the array to get. + Returns an array of transposed . + HRESULT ID3D10EffectMatrixVariable::GetMatrixTransposeArray([Out, Buffer] float* pData,[None] int Offset,[None] int Count) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set a floating-point matrix. + + A reference to the first element in the matrix. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectMatrixVariable::SetMatrix([In] SHARPDX_MATRIX* pData) + + + + Get a matrix. + + A reference to the first element in a matrix. + HRESULT ID3D10EffectMatrixVariable::GetMatrix([Out] SHARPDX_MATRIX* pData) + + + + Set an array of floating-point matrices. + + A reference to the first matrix. + The number of matrix elements to skip from the start of the array. + The number of elements to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectMatrixVariable::SetMatrixArray([In, Buffer] SHARPDX_MATRIX* pData,[None] int Offset,[None] int Count) + + + + Get an array of matrices. + + A reference to the first element of the first matrix in an array of matrices. + The offset (in number of matrices) between the start of the array and the first matrix returned. + The number of matrices in the returned array. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectMatrixVariable::GetMatrixArray([Out, Buffer] SHARPDX_MATRIX* pData,[None] int Offset,[None] int Count) + + + + Transpose and set a floating-point matrix. + + + Transposing a matrix will rearrange the data order from row-column order to column-row order (or vice versa). + + A reference to the first element of a matrix. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectMatrixVariable::SetMatrixTranspose([In] SHARPDX_MATRIX* pData) + + + + Transpose and get a floating-point matrix. + + + Transposing a matrix will rearrange the data order from row-column order to column-row order (or vice versa). + + A reference to the first element of a transposed matrix. + HRESULT ID3D10EffectMatrixVariable::GetMatrixTranspose([Out] SHARPDX_MATRIX* pData) + + + + Transpose and set an array of floating-point matrices. + + + Transposing a matrix will rearrange the data order from row-column order to column-row order (or vice versa). + + A reference to an array of matrices. + The offset (in number of matrices) between the start of the array and the first matrix to set. + The number of matrices in the array to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectMatrixVariable::SetMatrixTransposeArray([In, Buffer] SHARPDX_MATRIX* pData,[None] int Offset,[None] int Count) + + + + Transpose and get an array of floating-point matrices. + + + Transposing a matrix will rearrange the data order from row-column order to column-row order (or vice versa). + + A reference to the first element of an array of tranposed matrices. + The offset (in number of matrices) between the start of the array and the first matrix to get. + The number of matrices in the array to get. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectMatrixVariable::GetMatrixTransposeArray([Out, Buffer] SHARPDX_MATRIX* pData,[None] int Offset,[None] int Count) + + + + A pass interface encapsulates state assignments within a technique. + + ID3D10EffectPass + + + + Set the state contained in a pass to the device. + + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT Apply([None] UINT Flags) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Test a pass to see if it contains valid syntax. + + TRUE if the code syntax is valid; otherwise FALSE. + BOOL ID3D10EffectPass::IsValid() + + + + Get a pass description. + + + A pass is a block of code that sets render state and shaders (which in turn sets constant buffers, samplers and textures). An effect technique contains one or more passes. See {{techniques and passes}}. + + A reference to a pass description (see ). + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectPass::GetDesc([Out] D3D10_PASS_DESC* pDesc) + + + + Get a vertex-shader description. + + + An effect pass can contain render state assignments and shader object assignments. + + A reference to a vertex-shader description (see ). + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectPass::GetVertexShaderDesc([Out] D3D10_PASS_SHADER_DESC* pDesc) + + + + Get a geometry-shader description. + + + An effect pass can contain render state assignments and shader object assignments. + + A reference to a geometry-shader description (see ). + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectPass::GetGeometryShaderDesc([Out] D3D10_PASS_SHADER_DESC* pDesc) + + + + Get a pixel-shader description. + + + An effect pass can contain render state assignments and shader object assignments. + + A reference to a pixel-shader description (see ). + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectPass::GetPixelShaderDesc([Out] D3D10_PASS_SHADER_DESC* pDesc) + + + + Get an annotation by index. + + A zero-based index. + A reference to an . + ID3D10EffectVariable* ID3D10EffectPass::GetAnnotationByIndex([None] int Index) + + + + Get an annotation by name. + + The name of the annotation. + A reference to an . + ID3D10EffectVariable* ID3D10EffectPass::GetAnnotationByName([None] const char* Name) + + + + Set the state contained in a pass to the device. + + Unused. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectPass::Apply([None] int Flags) + + + + Generate a mask for allowing/preventing state changes. + + A reference to a state-block mask (see ). + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectPass::ComputeStateBlockMask([None] D3D10_STATE_BLOCK_MASK* pStateBlockMask) + + + + Test a pass to see if it contains valid syntax. + + BOOL ID3D10EffectPass::IsValid() + + + + Get a pass description. + + + A pass is a block of code that sets render state and shaders (which in turn sets constant buffers, samplers and textures). An effect technique contains one or more passes. See {{techniques and passes}}. + + HRESULT ID3D10EffectPass::GetDesc([Out] D3D10_PASS_DESC* pDesc) + + + + Get a vertex-shader description. + + + An effect pass can contain render state assignments and shader object assignments. + + HRESULT ID3D10EffectPass::GetVertexShaderDesc([Out] D3D10_PASS_SHADER_DESC* pDesc) + + + + Get a geometry-shader description. + + + An effect pass can contain render state assignments and shader object assignments. + + HRESULT ID3D10EffectPass::GetGeometryShaderDesc([Out] D3D10_PASS_SHADER_DESC* pDesc) + + + + Get a pixel-shader description. + + + An effect pass can contain render state assignments and shader object assignments. + + HRESULT ID3D10EffectPass::GetPixelShaderDesc([Out] D3D10_PASS_SHADER_DESC* pDesc) + + + + Describes an effect pass, which contains pipeline state. + + + Get a pass description by calling ; an effect technique contains one or more passes. + + D3D10_PASS_DESC + + + + A string that contains the name of the pass; otherwise NULL. + + const char* Name + + + + The number of annotations. + + int Annotations + + + + A reference to the input signature or the vertex shader; otherwise NULL. + + byte* pIAInputSignature + + + + The size of the input signature (in bytes). + + SIZE_T IAInputSignatureSize + + + + The stencil-reference value used in the depth-stencil state (see {{Configuring Depth-Stencil Functionality (Direct3D 10)}}). + + int StencilRef + + + + The sample mask for the blend state (see {{Configuring Blending Functionality (Direct3D 10)}}). + + int SampleMask + + + + The per-component blend factors (RGBA) for the blend state (see {{Configuring Blending Functionality (Direct3D 10)}}). + + SHARPDX_COLOR4 BlendFactor + + + + Returns the signature of this Effect pass. + + + + + Describes an effect variable that contains a shader. + + + To get a shader description, call a method like . + + D3D10_PASS_SHADER_DESC + + + + A reference to the variable that the shader came from. If it is an inline shader assignment, the returned interface will be an anonymous shader variable, which is not retrievable any other way. Its name in the variable description will be "$Anonymous". If there is no assignment of this type in the pass block, this will point to a shader variable that returns false when IsValid is called. + + ID3D10EffectShaderVariable* pShaderVariable + + + + A zero-based array index; otherwise 0. + + int ShaderIndex + + + + A reference to the variable that the shader came from. If it is an inline shader assignment, the returned interface will be an anonymous shader variable, which is not retrievable any other way. Its name in the variable description will be "$Anonymous". If there is no assignment of this type in the pass block, this will point to a shader variable that returns false when IsValid is called. + + ID3D10EffectShaderVariable* pShaderVariable + + + + A pool interface represents a common memory space (or pool) for sharing variables between effects. + + ID3D10EffectPool + + + + Initializes a new instance of the class. + + The device. + The effect byte code. + + + + Initializes a new instance of the class. + + The device. + The effect byte code. + Effect compile options + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the effect that created the effect pool. + + A reference to an interface. + ID3D10Effect* ID3D10EffectPool::AsEffect() + + + + A rasterizer-variable interface accesses rasterizer state. + + ID3D10EffectRasterizerVariable + + + + Get a pointer to a rasterizer interface. + + Returns a pointer to a rasterizer interface (see ). + HRESULT ID3D10EffectRasterizerVariable::GetRasterizerState([None] int Index,[Out] ID3D10RasterizerState** ppRasterizerState) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a reference to a rasterizer interface. + + Index into an array of rasterizer interfaces. If there is only one rasterizer interface, use 0. + The address of a reference to a rasterizer interface (see ). + HRESULT ID3D10EffectRasterizerVariable::GetRasterizerState([None] int Index,[Out] ID3D10RasterizerState** ppRasterizerState) + + + + Get a reference to a variable that contains rasteriser state. + + + Effect variables are saved in memory in the backing store; when a technique is applied, the values in the backing store are copied to the device. Backing store data can used to recreate the variable when necessary. + + Index into an array of rasteriser-state descriptions. If there is only one rasteriser variable in the effect, use 0. + A reference to a rasteriser-state description (see ). + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectRasterizerVariable::GetBackingStore([None] int Index,[Out] D3D10_RASTERIZER_DESC* pRasterizerDesc) + + + + A render-target-view interface accesses a render target. + + ID3D10EffectRenderTargetViewVariable + + + + Set an array of render-targets. + + Set an array of render-target-view interfaces. See . + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectRenderTargetViewVariable::SetRenderTargetArray([In, Buffer] ID3D10RenderTargetView** ppResources,[None] int Offset,[None] int Count) + + + + Set an array of render-targets. + + Set an array of render-target-view interfaces. See . + The zero-based array index to store the first interface. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectRenderTargetViewVariable::SetRenderTargetArray([In, Buffer] ID3D10RenderTargetView** ppResources,[None] int Offset,[None] int Count) + + + + Get an array of render-targets. + + The number of elements in the array. + Returns an array of . + HRESULT ID3D10EffectRenderTargetViewVariable::GetRenderTargetArray([Out, Buffer] ID3D10RenderTargetView** ppResources,[None] int Offset,[None] int Count) + + + + Get an array of render-targets. + + The zero-based array index to get the first interface. + The number of elements in the array. + Returns an array of . + HRESULT ID3D10EffectRenderTargetViewVariable::GetRenderTargetArray([Out, Buffer] ID3D10RenderTargetView** ppResources,[None] int Offset,[None] int Count) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set a render-target. + + A reference to a render-target-view interface. See . + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectRenderTargetViewVariable::SetRenderTarget([None] ID3D10RenderTargetView* pResource) + + + + Get a render-target. + + The address of a reference to a render-target-view interface. See . + HRESULT ID3D10EffectRenderTargetViewVariable::GetRenderTarget([Out] ID3D10RenderTargetView** ppResource) + + + + Set an array of render-targets. + + Set an array of render-target-view interfaces. See . + The zero-based array index to store the first interface. + The number of elements in the array. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectRenderTargetViewVariable::SetRenderTargetArray([In, Buffer] ID3D10RenderTargetView** ppResources,[None] int Offset,[None] int Count) + + + + Get an array of render-targets. + + A reference to an array of render-target-view interfaces. See . + The zero-based array index to get the first interface. + The number of elements in the array. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectRenderTargetViewVariable::GetRenderTargetArray([Out, Buffer] ID3D10RenderTargetView** ppResources,[None] int Offset,[None] int Count) + + + + A sampler interface accesses sampler state. + + ID3D10EffectSamplerVariable + + + + Get a reference to a sampler interface. + + Returns a reference to a sampler interface (see ). + HRESULT ID3D10EffectSamplerVariable::GetSampler([None] int Index,[Out] ID3D10SamplerState** ppSampler) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a reference to a sampler interface. + + Index into an array of sampler interfaces. If there is only one sampler interface, use 0. + The address of a reference to a sampler interface (see ). + HRESULT ID3D10EffectSamplerVariable::GetSampler([None] int Index,[Out] ID3D10SamplerState** ppSampler) + + + + Get a reference to a variable that contains sampler state. + + Index into an array of sampler descriptions. If there is only one sampler variable in the effect, use 0. + A reference to a sampler description (see ). + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectSamplerVariable::GetBackingStore([None] int Index,[Out] D3D10_SAMPLER_DESC* pSamplerDesc) + + + + Describes an effect shader. + + + To get an effect-shader description, call . + + D3D10_EFFECT_SHADER_DESC + + + + Passed into CreateInputLayout. Only valid on a vertex shader or geometry shader. See {{ID3D10Device_CreateInputLayout}}. + + const byte* pInputSignature + + + + A reference to the compiled shader. + + const byte* pBytecode + + + + The length of pBytecode. + + int BytecodeLength + + + + A string that constains a declaration of the {{stream output}} from a geometry shader. + + const char* SODecl + + + + The number of entries in the input signature. + + int NumInputSignatureEntries + + + + The number of entries in the output signature. + + int NumOutputSignatureEntries + + + + Gets the signature passed into InputLayout. Only valid on a vertex shader or geometry shader. + + The signature. + + + + Gets the bytecode from the compiled shader. + + The bytecode. + + + + TRUE is the shader is defined inline; otherwise FALSE. + + BOOL IsInline + + + + A shader-resource interface accesses a shader resource. + + ID3D10EffectShaderResourceVariable + + + + Set an array of shader resources. + + The address of an array of shader-resource-view interfaces. See . + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectShaderResourceVariable::SetResourceArray([None] ID3D10ShaderResourceView** ppResources,[None] int Offset,[None] int Count) + + + + Set an array of shader resources. + + The address of an array of shader-resource-view interfaces. See . + The zero-based array index to get the first interface. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectShaderResourceVariable::SetResourceArray([None] ID3D10ShaderResourceView** ppResources,[None] int Offset,[None] int Count) + + + + Get an array of shader resources. + + The number of elements in the array. + Returns an array of shader-resource-view interfaces. See . + HRESULT ID3D10EffectShaderResourceVariable::GetResourceArray([Out] ID3D10ShaderResourceView** ppResources,[None] int Offset,[None] int Count) + + + + Get an array of shader resources. + + The zero-based array index to get the first interface. + The number of elements in the array. + Returns an array of shader-resource-view interfaces. See . + HRESULT ID3D10EffectShaderResourceVariable::GetResourceArray([Out] ID3D10ShaderResourceView** ppResources,[None] int Offset,[None] int Count) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set a shader resource. + + The address of a reference to a shader-resource-view interface. See . + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectShaderResourceVariable::SetResource([None] ID3D10ShaderResourceView* pResource) + + + + Get a shader resource. + + The address of a reference to a shader-resource-view interface. See . + HRESULT ID3D10EffectShaderResourceVariable::GetResource([Out] ID3D10ShaderResourceView** ppResource) + + + + Set an array of shader resources. + + The address of an array of shader-resource-view interfaces. See . + The zero-based array index to get the first interface. + The number of elements in the array. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectShaderResourceVariable::SetResourceArray([In, Buffer] ID3D10ShaderResourceView** ppResources,[None] int Offset,[None] int Count) + + + + Get an array of shader resources. + + The address of an array of shader-resource-view interfaces. See . + The zero-based array index to get the first interface. + The number of elements in the array. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectShaderResourceVariable::GetResourceArray([Out, Buffer] ID3D10ShaderResourceView** ppResources,[None] int Offset,[None] int Count) + + + + An effect-scalar-variable interface accesses scalar values. + + ID3D10EffectScalarVariable + + + + Set a floating-point variable. + + A reference to the variable. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::SetFloat([None] float Value) + + + + Set an array of floating-point variables. + + A reference to the start of the data to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::SetFloatArray([In, Buffer] float* pData,[None] int Offset,[None] int Count) + + + + Set an array of floating-point variables. + + A reference to the start of the data to set. + Must be set to 0; this is reserved for future use. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::SetFloatArray([In, Buffer] float* pData,[None] int Offset,[None] int Count) + + + + Get an array of floating-point variables. + + The number of array elements to set. + Returns an array of floats. + HRESULT ID3D10EffectScalarVariable::GetFloatArray([Out, Buffer] float* pData,[None] int Offset,[None] int Count) + + + + Get an array of floating-point variables. + + Must be set to 0; this is reserved for future use. + The number of array elements to set. + Returns an array of floats. + HRESULT ID3D10EffectScalarVariable::GetFloatArray([Out, Buffer] float* pData,[None] int Offset,[None] int Count) + + + + Set an integer variable. + + A reference to the variable. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::SetInt([None] int Value) + + + + Set an array of integer variables. + + A reference to the start of the data to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::SetIntArray([In, Buffer] int* pData,[None] int Offset,[None] int Count) + + + + Set an array of integer variables. + + A reference to the start of the data to set. + Must be set to 0; this is reserved for future use. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::SetIntArray([In, Buffer] int* pData,[None] int Offset,[None] int Count) + + + + Get an array of integer variables. + + The number of array elements to set. + Returns an array of integer variables. + HRESULT ID3D10EffectScalarVariable::GetIntArray([Out, Buffer] int* pData,[None] int Offset,[None] int Count) + + + + Get an array of integer variables. + + Must be set to 0; this is reserved for future use. + The number of array elements to set. + Returns an array of integer variables. + HRESULT ID3D10EffectScalarVariable::GetIntArray([Out, Buffer] int* pData,[None] int Offset,[None] int Count) + + + + Set a boolean variable. + + A reference to the variable. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::SetBool([None] BOOL Value) + + + + Get a boolean variable. + + Returns a boolean. + HRESULT ID3D10EffectScalarVariable::GetBool([Out] BOOL* pValue) + + + + Set an array of boolean variables. + + A reference to the start of the data to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::SetBoolArray([In, Buffer] BOOL* pData,[None] int Offset,[None] int Count) + + + + Set an array of boolean variables. + + A reference to the start of the data to set. + Must be set to 0; this is reserved for future use. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::SetBoolArray([In, Buffer] BOOL* pData,[None] int Offset,[None] int Count) + + + + Get an array of boolean variables. + + Must be set to 0; this is reserved for future use. + The number of array elements to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::GetBoolArray([Out, Buffer] BOOL* pData,[None] int Offset,[None] int Count) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set a floating-point variable. + + A reference to the variable. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::SetFloat([None] float Value) + + + + Get a floating-point variable. + + A reference to the variable. + HRESULT ID3D10EffectScalarVariable::GetFloat([Out] float* pValue) + + + + Set an array of floating-point variables. + + A reference to the start of the data to set. + Must be set to 0; this is reserved for future use. + The number of array elements to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::SetFloatArray([In, Buffer] float* pData,[None] int Offset,[None] int Count) + + + + Get an array of floating-point variables. + + A reference to the start of the data to set. + Must be set to 0; this is reserved for future use. + The number of array elements to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::GetFloatArray([Out, Buffer] float* pData,[None] int Offset,[None] int Count) + + + + Set an integer variable. + + A reference to the variable. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::SetInt([None] int Value) + + + + Get an integer variable. + + A reference to the variable. + HRESULT ID3D10EffectScalarVariable::GetInt([Out] int* pValue) + + + + Set an array of integer variables. + + A reference to the start of the data to set. + Must be set to 0; this is reserved for future use. + The number of array elements to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::SetIntArray([In, Buffer] int* pData,[None] int Offset,[None] int Count) + + + + Get an array of integer variables. + + A reference to the start of the data to set. + Must be set to 0; this is reserved for future use. + The number of array elements to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::GetIntArray([Out, Buffer] int* pData,[None] int Offset,[None] int Count) + + + + Set a boolean variable. + + A reference to the variable. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::SetBool([None] BOOL Value) + + + + Get a boolean variable. + + A reference to the variable. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::GetBool([Out] BOOL* pValue) + + + + Set an array of boolean variables. + + A reference to the start of the data to set. + Must be set to 0; this is reserved for future use. + The number of array elements to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::SetBoolArray([In, Buffer] BOOL* pData,[None] int Offset,[None] int Count) + + + + Get an array of boolean variables. + + A reference to the start of the data to set. + Must be set to 0; this is reserved for future use. + The number of array elements to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectScalarVariable::GetBoolArray([Out, Buffer] BOOL* pData,[None] int Offset,[None] int Count) + + + + A string-variable interface accesses a string variable. + + ID3D10EffectStringVariable + + + + Get the string. + + Returns a reference to the string. + HRESULT ID3D10EffectStringVariable::GetString([Out] const char** ppString) + + + + Get an array of strings. + + The number of strings in the returned array. + Returns a reference to the first string in the array. + HRESULT ID3D10EffectStringVariable::GetStringArray([Out, Buffer] const char** ppStrings,[None] int Offset,[None] int Count) + + + + Get an array of strings. + + The offset (in number of strings) between the start of the array and the first string to get. + The number of strings in the returned array. + Returns a reference to the first string in the array. + HRESULT ID3D10EffectStringVariable::GetStringArray([Out, Buffer] const char** ppStrings,[None] int Offset,[None] int Count) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the string. + + A reference to the string. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectStringVariable::GetString([Out] const void** ppString) + + + + Get an array of strings. + + A reference to the first string in the array. + The offset (in number of strings) between the start of the array and the first string to get. + The number of strings in the returned array. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectStringVariable::GetStringArray([Out, Buffer] const void** ppStrings,[None] int Offset,[None] int Count) + + + + A vector-variable interface accesses a four-component vector. + + ID3D10EffectVectorVariable + + + + Get a four-component vector that contains integer data. + + Returns a four-component vector that contains integer data + HRESULT ID3D10EffectVectorVariable::GetIntVector([Out] int* pData) + + + + Get a four-component vector that contains floating-point data. + + Returns a four-component vector that contains floating-point data. + HRESULT ID3D10EffectVectorVariable::GetFloatVector([Out] float* pData) + + + + Get a four-component vector that contains boolean data. + + a four-component vector that contains boolean data. + HRESULT ID3D10EffectVectorVariable::GetBoolVector([Out, Buffer] BOOL* pData) + + + + Set an array of four-component vectors that contain integer data. + + A reference to the start of the data to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::SetIntVectorArray([In, Buffer] int* pData,[None] int Offset,[None] int Count) + + + + Set an array of four-component vectors that contain floating-point data. + + A reference to the start of the data to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::SetFloatVectorArray([In, Buffer] float* pData,[None] int Offset,[None] int Count) + + + + Set a two-component vector that contains floating-point data. + + A reference to the first component. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::SetFloatVector([In] float* pData) + + + + Set a three-component vector that contains floating-point data. + + A reference to the first component. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::SetFloatVector([In] float* pData) + + + + Set a four-component color that contains floating-point data. + + A reference to the first component. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::SetFloatVector([In] float* pData) + + + + Set an array of four-component color that contain floating-point data. + + A reference to the start of the data to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::SetFloatVectorArray([In, Buffer] float* pData,[None] int Offset,[None] int Count) + + + + Set an array of four-component vectors that contain boolean data. + + A reference to the start of the data to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::SetBoolVectorArray([In, Buffer] BOOL* pData,[None] int Offset,[None] int Count) + + + + Get an array of four-component vectors that contain integer data. + + The number of array elements to set. + Returns an array of four-component vectors that contain integer data. + HRESULT ID3D10EffectVectorVariable::GetIntVectorArray([Out, Buffer] int* pData,[None] int Offset,[None] int Count) + + + + Get an array of four-component vectors that contain floating-point data. + + The number of array elements to set. + Returns an array of four-component vectors that contain floating-point data. + HRESULT ID3D10EffectVectorVariable::GetFloatVectorArray([None] float* pData,[None] int Offset,[None] int Count) + + + + Get an array of four-component vectors that contain boolean data. + + The number of array elements to set. + an array of four-component vectors that contain boolean data. + HRESULT ID3D10EffectVectorVariable::GetBoolVectorArray([Out, Buffer] BOOL* pData,[None] int Offset,[None] int Count) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set a four-component vector that contains boolean data. + + A reference to the first component. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::SetBoolVector([In, Buffer] BOOL* pData) + + + + Set a four-component vector that contains integer data. + + A reference to the first component. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::SetIntVector([In] SHARPDX_INT4* pData) + + + + Set a four-component vector that contains floating-point data. + + A reference to the first component. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::SetFloatVector([In] SHARPDX_VECTOR4* pData) + + + + Get a four-component vector that contains boolean data. + + A reference to the first component. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::GetBoolVector([Out, Buffer] BOOL* pData) + + + + Get a four-component vector that contains integer data. + + A reference to the first component. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::GetIntVector([Out] SHARPDX_INT4* pData) + + + + Get a four-component vector that contains floating-point data. + + A reference to the first component. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::GetFloatVector([Out] SHARPDX_VECTOR4* pData) + + + + Set an array of four-component vectors that contain boolean data. + + A reference to the start of the data to set. + Must be set to 0; this is reserved for future use. + The number of array elements to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::SetBoolVectorArray([In, Buffer] BOOL* pData,[None] int Offset,[None] int Count) + + + + Set an array of four-component vectors that contain integer data. + + A reference to the start of the data to set. + Must be set to 0; this is reserved for future use. + The number of array elements to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::SetIntVectorArray([In, Buffer] SHARPDX_INT4* pData,[None] int Offset,[None] int Count) + + + + Set an array of four-component vectors that contain floating-point data. + + A reference to the start of the data to set. + Must be set to 0; this is reserved for future use. + The number of array elements to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::SetFloatVectorArray([In, Buffer] SHARPDX_VECTOR4* pData,[None] int Offset,[None] int Count) + + + + Get an array of four-component vectors that contain boolean data. + + A reference to the start of the data to set. + Must be set to 0; this is reserved for future use. + The number of array elements to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::GetBoolVectorArray([Out, Buffer] BOOL* pData,[None] int Offset,[None] int Count) + + + + Get an array of four-component vectors that contain integer data. + + A reference to the start of the data to set. + Must be set to 0; this is reserved for future use. + The number of array elements to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::GetIntVectorArray([Out, Buffer] SHARPDX_INT4* pData,[None] int Offset,[None] int Count) + + + + Get an array of four-component vectors that contain floating-point data. + + A reference to the start of the data to set. + Must be set to 0; this is reserved for future use. + The number of array elements to set. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectVectorVariable::GetFloatVectorArray([Out, Buffer] SHARPDX_VECTOR4* pData,[None] int Offset,[None] int Count) + + + + The ID3DX10Font interface encapsulates the textures and resources needed to render a specific font on a specific device. + + ID3DX10Font + + + + Initializes a new instance of the class. + + The device. + The font description. + + + + Initializes a new instance of the class. + + The device. + The height. + The width. + The weight. + The mip levels. + if set to true [is italic]. + The character set. + The precision. + The quality. + The pitch and family. + Name of the face. + + + + Load formatted text into video memory to improve the efficiency of rendering to the device. This method supports ANSI and Unicode strings. + + + The compiler setting also determines the function version. If Unicode is defined, the function call resolves to PreloadTextW. Otherwise, the function call resolves to PreloadTextA because ANSI strings are being used. This method generates textures that contain glyphs that represent the input text. The glyphs are drawn as a series of triangles. Text will not be rendered to the device; ID3DX10Font::DrawText must still be called to render the text. However, by preloading text into video memory, ID3DX10Font::DrawText will use substantially fewer CPU resources. This method internally converts characters to glyphs using the GDI function {{GetCharacterPlacement}}. + + Pointer to a string of characters to be loaded into video memory. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR; otherwise, the data type resolves to LPCSTR. See Remarks. + If the method succeeds, the return value is S_OK. If the method fails, the return value can be one of the following: D3DERR_INVALIDCALL, D3DXERR_INVALIDDATA. + HRESULT ID3DX10Font::PreloadTextW([None] const wchar_t* pString,[None] int Count) + + + + Draw formatted text. This method supports ANSI and Unicode strings. + + + The parameters of this method are very similar to those of the {{GDI DrawText}} function. This method supports both ANSI and Unicode strings. Unless the DT_NOCLIP format is used, this method clips the text so that it does not appear outside the specified rectangle. All formatting is assumed to have multiple lines unless the DT_SINGLELINE format is specified. If the selected font is too large for the rectangle, this method does not attempt to substitute a smaller font. This method supports only fonts whose escapement and orientation are both zero. + + Reference to an ID3DX10Sprite object that contains the string you wish to draw. Can be NULL, in which case Direct3D will render the string with its own sprite object. To improve efficiency, a sprite object should be specified if ID3DX10Font::DrawText is to be called more than once in a row. + Pointer to a string to draw. If UNICODE is defined, this parameter type resolves to an LPCWSTR, otherwise, the type resolves to an LPCSTR. If the Count parameter is -1, the string must be NULL terminated. + Pointer to a structure that contains the rectangle, in logical coordinates, in which the text is to be formatted. As with any RECT object, the coordinate value of the rectangle's right side must be greater than that of its left side. Likewise, the coordinate value of the bottom must be greater than that of the top. + Specify the method of formatting the text. It can be any combination of the following values: ItemDescription DT_BOTTOM Justify the text to the bottom of the rectangle. This value must be combined with DT_SINGLELINE. DT_CALCRECT Tell DrawText to automatically calculate the width and height of the rectangle based on the length of the string you tell it to draw. If there are multiple lines of text, ID3DX10Font::DrawText uses the width of the rectangle pointed to by the pRect parameter and extends the base of the rectangle to bound the last line of text. If there is only one line of text, ID3DX10Font::DrawText modifies the right side of the rectangle so that it bounds the last character in the line. In either case, ID3DX10Font::DrawText returns the height of the formatted text but does not draw the text. DT_CENTER Center text horizontally in the rectangle. DT_EXPANDTABS Expand tab characters. The default number of characters per tab is eight. DT_LEFT Align text to the left. DT_NOCLIP Draw without clipping. ID3DX10Font::DrawText is somewhat faster when DT_NOCLIP is used. DT_RIGHT Align text to the right. DT_RTLREADING Display text in right-to-left reading order for bidirectional text when a Hebrew or Arabic font is selected. The default reading order for all text is left-to-right. DT_SINGLELINE Display text on a single line only. Carriage returns and line feeds do not break the line. DT_TOP Top-justify text. DT_VCENTER Center text vertically (single line only). DT_WORDBREAK Break words. Lines are automatically broken between words if a word would extend past the edge of the rectangle specified by the pRect parameter. A carriage return/line feed sequence also breaks the line. ? + Color of the text. See . + If the function succeeds, the return value is the height of the text in logical units. If DT_VCENTER or DT_BOTTOM is specified, the return value is the offset from pRect (top to the bottom) of the drawn text. If the function fails, the return value is zero. + int ID3DX10Font::DrawTextW([None] LPD3DX10SPRITE pSprite,[None] const wchar_t* pString,[None] int Count,[None] RECT* pRect,[None] int Format,[None] D3DXCOLOR Color) + + + + Measures the specified sprite. + + Reference to an ID3DX10Sprite object that contains the string you wish to draw. Can be NULL, in which case Direct3D will render the string with its own sprite object. To improve efficiency, a sprite object should be specified if ID3DX10Font::DrawText is to be called more than once in a row. + A string to measure. + A structure that contains the rectangle, in logical coordinates, in which the text is to be formatted. As with any RECT object, the coordinate value of the rectangle's right side must be greater than that of its left side. Likewise, the coordinate value of the bottom must be greater than that of the top. + Specify the method of formatting the text. + + + + + Initializes a new instance of the class. + + The native pointer. + + + + Retrieve the Direct3D device associated with the font object. + + + Note??Calling this method will increase the internal reference count on the ID3D10Device interface. Be sure to call IUnknown when you are done using this ID3D10Device interface or you will have a memory leak. + + Address of a reference to an ID3D10Device interface, representing the Direct3D device object associated with the font object. + If the method succeeds, the return value is S_OK. If the method fails, the return value can be one of the following: D3DERR_INVALIDCALL, D3DXERR_INVALIDDATA. + HRESULT ID3DX10Font::GetDevice([Out] ID3D10Device** ppDevice) + + + + Get a description of the current font object. + + + This method describes Unicode font objects if UNICODE is defined. Otherwise GetDescA is called, which returns a reference to the D3DX10FONT_DESCA structure. + + Pointer to a {{D3DX10_FONT_DESC}} structure that describes the font object. If UNICODE is defined, a reference to a D3DX10FONT_DESCW is returned; otherwise a reference to a D3DX10FONT_DESCA is returned. + If the method succeeds, the return value is S_OK. If the method fails, the following value will be returned: D3DERR_INVALIDCALL. + HRESULT ID3DX10Font::GetDescW([Out] D3DX10_FONT_DESCW* pDesc) + + + + Retrieve font characteristics. + + Pointer to a {{TEXTMETRIC}} structure, which contains font properties. If Unicode is defined, the function returns a TEXTMETRICW structure. Otherwise, the function returns a TEXTMETRICA structure. + Nonzero if the function is successful; otherwise 0. + BOOL ID3DX10Font::GetTextMetricsW([In] void* pTextMetrics) + + + + Return a handle to a display device context (DC) that has the font set onto it. + + Handle to a display DC. + void* ID3DX10Font::GetDC() + + + + Return information about the placement and orientation of a glyph in a character cell. + + Glyph identifier. + Address of a reference to a ID3D10Texture object that contains the glyph. + Pointer to the smallest rectangle object that completely encloses the glyph. See . + Pointer to the two-dimensional vector that connects the origin of the current character cell to the origin of the next character cell. See . + If the method succeeds, the return value is S_OK. If the method fails, the return value can be one of the following: D3DERR_INVALIDCALL, D3DXERR_INVALIDDATA. + HRESULT ID3DX10Font::GetGlyphData([None] int Glyph,[Out] ID3D10ShaderResourceView** ppTexture,[Out] RECT* pBlackBox,[Out] POINT* pCellInc) + + + + Load a series of characters into video memory to improve the efficiency of rendering to the device. + + + This method generates textures containing glyphs that represent the input characters. The glyphs are drawn as a series of triangles. Characters will not be rendered to the device; ID3DX10Font::DrawText must still be called to render the characters. However, by pre-loading characters into video memory, ID3DX10Font::DrawText will use substantially fewer CPU resources. This method internally converts characters to glyphs using the GDI function {{GetCharacterPlacement}}. + + ID of the first character to be loaded into video memory. + ID of the last character to be loaded into video memory. + If the method succeeds, the return value is S_OK. If the method fails, the return value can be one of the following: D3DERR_INVALIDCALL, D3DXERR_INVALIDDATA. + HRESULT ID3DX10Font::PreloadCharacters([None] int First,[None] int Last) + + + + Load a series of glyphs into video memory to improve the efficiency of rendering to the device. + + + This method generates textures that contain the input glyphs. The glyphs are drawn as a series of triangles. Glyphs will not be rendered to the device; ID3DX10Font::DrawText must still be called to render the glyphs. However, by pre-loading glyphs into video memory, ID3DX10Font::DrawText will use substantially fewer CPU resources. + + ID of the first glyph to be loaded into video memory. + ID of the last glyph to be loaded into video memory. + If the method succeeds, the return value is S_OK. If the method fails, the return value can be one of the following: D3DERR_INVALIDCALL, D3DXERR_INVALIDDATA. + HRESULT ID3DX10Font::PreloadGlyphs([None] int First,[None] int Last) + + + + Load formatted text into video memory to improve the efficiency of rendering to the device. This method supports ANSI and Unicode strings. + + + The compiler setting also determines the function version. If Unicode is defined, the function call resolves to PreloadTextW. Otherwise, the function call resolves to PreloadTextA because ANSI strings are being used. This method generates textures that contain glyphs that represent the input text. The glyphs are drawn as a series of triangles. Text will not be rendered to the device; ID3DX10Font::DrawText must still be called to render the text. However, by preloading text into video memory, ID3DX10Font::DrawText will use substantially fewer CPU resources. This method internally converts characters to glyphs using the GDI function {{GetCharacterPlacement}}. + + Pointer to a string of characters to be loaded into video memory. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR; otherwise, the data type resolves to LPCSTR. See Remarks. + Number of characters in the text string. + If the method succeeds, the return value is S_OK. If the method fails, the return value can be one of the following: D3DERR_INVALIDCALL, D3DXERR_INVALIDDATA. + HRESULT ID3DX10Font::PreloadTextW([None] const wchar_t* pString,[None] int Count) + + + + Draw formatted text. This method supports ANSI and Unicode strings. + + + The parameters of this method are very similar to those of the {{GDI DrawText}} function. This method supports both ANSI and Unicode strings. Unless the DT_NOCLIP format is used, this method clips the text so that it does not appear outside the specified rectangle. All formatting is assumed to have multiple lines unless the DT_SINGLELINE format is specified. If the selected font is too large for the rectangle, this method does not attempt to substitute a smaller font. This method supports only fonts whose escapement and orientation are both zero. + + Pointer to an ID3DX10Sprite object that contains the string you wish to draw. Can be NULL, in which case Direct3D will render the string with its own sprite object. To improve efficiency, a sprite object should be specified if ID3DX10Font::DrawText is to be called more than once in a row. + Pointer to a string to draw. If UNICODE is defined, this parameter type resolves to an LPCWSTR, otherwise, the type resolves to an LPCSTR. If the Count parameter is -1, the string must be NULL terminated. + The number of characters in the string. If Count is -1, then the pString parameter is assumed to be a reference to a sprite containing a NULL-terminated string and ID3DX10Font::DrawText computes the character count automatically. + Pointer to a structure that contains the rectangle, in logical coordinates, in which the text is to be formatted. As with any RECT object, the coordinate value of the rectangle's right side must be greater than that of its left side. Likewise, the coordinate value of the bottom must be greater than that of the top. + Specify the method of formatting the text. It can be any combination of the following values: ItemDescription DT_BOTTOM Justify the text to the bottom of the rectangle. This value must be combined with DT_SINGLELINE. DT_CALCRECT Tell DrawText to automatically calculate the width and height of the rectangle based on the length of the string you tell it to draw. If there are multiple lines of text, ID3DX10Font::DrawText uses the width of the rectangle pointed to by the pRect parameter and extends the base of the rectangle to bound the last line of text. If there is only one line of text, ID3DX10Font::DrawText modifies the right side of the rectangle so that it bounds the last character in the line. In either case, ID3DX10Font::DrawText returns the height of the formatted text but does not draw the text. DT_CENTER Center text horizontally in the rectangle. DT_EXPANDTABS Expand tab characters. The default number of characters per tab is eight. DT_LEFT Align text to the left. DT_NOCLIP Draw without clipping. ID3DX10Font::DrawText is somewhat faster when DT_NOCLIP is used. DT_RIGHT Align text to the right. DT_RTLREADING Display text in right-to-left reading order for bidirectional text when a Hebrew or Arabic font is selected. The default reading order for all text is left-to-right. DT_SINGLELINE Display text on a single line only. Carriage returns and line feeds do not break the line. DT_TOP Top-justify text. DT_VCENTER Center text vertically (single line only). DT_WORDBREAK Break words. Lines are automatically broken between words if a word would extend past the edge of the rectangle specified by the pRect parameter. A carriage return/line feed sequence also breaks the line. ? + Color of the text. See . + If the function succeeds, the return value is the height of the text in logical units. If DT_VCENTER or DT_BOTTOM is specified, the return value is the offset from pRect (top to the bottom) of the drawn text. If the function fails, the return value is zero. + int ID3DX10Font::DrawTextW([None] LPD3DX10SPRITE pSprite,[None] const wchar_t* pString,[None] int Count,[None] RECT* pRect,[None] int Format,[None] D3DXCOLOR Color) + + + + Retrieve the Direct3D device associated with the font object. + + + Note??Calling this method will increase the internal reference count on the ID3D10Device interface. Be sure to call IUnknown when you are done using this ID3D10Device interface or you will have a memory leak. + + HRESULT ID3DX10Font::GetDevice([Out] ID3D10Device** ppDevice) + + + + Get a description of the current font object. + + + This method describes Unicode font objects if UNICODE is defined. Otherwise GetDescA is called, which returns a reference to the D3DX10FONT_DESCA structure. + + HRESULT ID3DX10Font::GetDescW([Out] D3DX10_FONT_DESCW* pDesc) + + + + Return a handle to a display device context (DC) that has the font set onto it. + + void* ID3DX10Font::GetDC() + + + + Defines possible character sets for fonts. + + CHARSET + + + + The ANSI character set. + + + + + The Arabic character set. + + + + + The Baltic character set. + + + + + The Chinese character set. + + + + + The default system character set. + + + + + The East Europe character set. + + + + + The GB2312 character set. + + + + + The Greek character set. + + + + + The Hangul character set. + + + + + The Hebrew character set. + + + + + The Johab character set. + + + + + The Mac character set. + + + + + The OEM character set. + + + + + The Russian character set. + + + + + The ShiftJIS character set. + + + + + The symbol character set. + + + + + The Thai character set. + + + + + The Turkish character set. + + + + + The Vietnamese character set. + + + + + Specifies formatting options for text rendering. + + DT + + + + Align the text to the bottom. + + + + + Align the text to the center. + + + + + Expand tab characters. + + + + + Align the text to the left. + + + + + Don't clip the text. + + + + + Align the text to the right. + + + + + Rendering the text in right-to-left reading order. + + + + + Force all text to a single line. + + + + + Align the text to the top. + + + + + Vertically align the text to the center. + + + + + Allow word breaks. + + + + + Defines pitch and family settings for fonts. + + + + + Use the Decorative family. + + + + + Default pitch. + + + + + The font family doesn't matter. + + + + + Fixed pitch. + + + + + Use the Modern family. + + + + + Mono pitch. + + + + + Use the Roman family. + + + + + Use the Script family. + + + + + Use the Swiss family. + + + + + Variable pitch. + + + + + Defines precision levels for font rendering. + + OutPrecision + + + + Default + + + + + String + + + + + Character + + + + + Stroke + + + + + TrueType + + + + + Device + + + + + Raster + + + + + TrueTypeOnly + + + + + Outline + + + + + ScreenOutline + + + + + PostScriptOnly + + + + + Specifies quality options for font rendering. + + QUALITY + + + + Default + + + + + Draft + + + + + Proof + + + + + Non antialiased + + + + + Antialiased + + + + + ClearType + + + + + ClearTypeNatural + + + + + Specifies weights for font rendering. + + FW + + + + Use a black weight. + + + + + Use a bold weight. + + + + + Use a demi-bold weight. + + + + + The font weight doesn't matter. + + + + + Use an extra bold weight. + + + + + Make the font extra light. + + + + + Use a heavy weight. + + + + + Make the font light. + + + + + Use a medium weight. + + + + + Use a normal weight. + + + + + Use a regular weight. + + + + + Use a semi-bold weight. + + + + + Make the font thin. + + + + + Use an ultra bold weight. + + + + + Make the font ultra light. + + + + + Type of data contained in an input slot. + + + Use these values to specify the type of data for a particular input element (see ) of an input-layout object. + + D3D10_INPUT_CLASSIFICATION + + + + Input data is per-vertex data. + + D3D10_INPUT_PER_VERTEX_DATA + + + + Input data is per-instance data. + + D3D10_INPUT_PER_INSTANCE_DATA + + + + Determines the fill mode to use when rendering triangles. + + + This enumeration is part of a rasterizer-state object description (see ). + + D3D10_FILL_MODE + + + + Draw lines connecting the vertices. {{Adjacent vertices}} are not drawn. + + D3D10_FILL_WIREFRAME + + + + Fill the triangles formed by the vertices. Adjacent vertices are not drawn. + + D3D10_FILL_SOLID + + + + Indicates triangles facing a particular direction are not drawn. + + + This enumeration is part of a rasterizer-state object description (see ). + + D3D10_CULL_MODE + + + + Always draw all triangles. + + D3D10_CULL_NONE + + + + Do not draw triangles that are front-facing. + + D3D10_CULL_FRONT + + + + Do not draw triangles that are back-facing. + + D3D10_CULL_BACK + + + + Identifies the type of {{resource}} being used. + + + This enumeration is used in , and . + + D3D10_RESOURCE_DIMENSION + + + + Resource is of unknown type. + + D3D10_RESOURCE_DIMENSION_UNKNOWN + + + + Resource is a {{buffer}}. + + D3D10_RESOURCE_DIMENSION_BUFFER + + + + Resource is a {{1D texture}}. + + D3D10_RESOURCE_DIMENSION_TEXTURE1D + + + + Resource is a {{2D texture}}. + + D3D10_RESOURCE_DIMENSION_TEXTURE2D + + + + Resource is a {{3D texture}}. + + D3D10_RESOURCE_DIMENSION_TEXTURE3D + + + + Specifies how to access a resource used in a depth-stencil {{view}}. + + + This enumeration is used in to create a depth-stencil view. + + D3D10_DSV_DIMENSION + + + + The resource will be accessed according to its type as determined from the actual instance this enumeration is paired with when the depth-stencil view is created. + + D3D10_DSV_DIMENSION_UNKNOWN + + + + The resource will be accessed as a {{1D texture}}. + + D3D10_DSV_DIMENSION_TEXTURE1D + + + + The resource will be accessed as an array of 1D textures. + + D3D10_DSV_DIMENSION_TEXTURE1DARRAY + + + + The resource will be accessed as a {{2D texture}}. + + D3D10_DSV_DIMENSION_TEXTURE2D + + + + The resource will be accessed as an array of 2D texture. + + D3D10_DSV_DIMENSION_TEXTURE2DARRAY + + + + The resource will be accessed as a 2D texture with multisampling. + + D3D10_DSV_DIMENSION_TEXTURE2DMS + + + + The resource will be accessed as an array of 2D textures with multisampling. + + D3D10_DSV_DIMENSION_TEXTURE2DMSARRAY + + + + Specifies how to access a resource used in a render-target {{view}}. + + + This enumeration is used in to create a render-target view. + + D3D10_RTV_DIMENSION + + + + The resource will be accessed according to its type as determined from the actual instance this enumeration is paired with when the render-target view is created. + + D3D10_RTV_DIMENSION_UNKNOWN + + + + The resource will be accessed as a {{buffer}}. + + D3D10_RTV_DIMENSION_BUFFER + + + + The resource will be accessed as a {{1D texture}}. + + D3D10_RTV_DIMENSION_TEXTURE1D + + + + The resource will be accessed as an array of 1D textures. + + D3D10_RTV_DIMENSION_TEXTURE1DARRAY + + + + The resource will be accessed as a {{2D texture}}. + + D3D10_RTV_DIMENSION_TEXTURE2D + + + + The resource will be accessed as an array of 2D textures. + + D3D10_RTV_DIMENSION_TEXTURE2DARRAY + + + + The resource will be accessed as a 2D texture with multisampling. + + D3D10_RTV_DIMENSION_TEXTURE2DMS + + + + The resource will be accessed as an array of 2D textures with multisampling. + + D3D10_RTV_DIMENSION_TEXTURE2DMSARRAY + + + + The resource will be accessed as a {{3D texture}}. + + D3D10_RTV_DIMENSION_TEXTURE3D + + + + Identifies expected resource use during rendering. The usage directly reflects whether a resource is accessible by the CPU and/or the GPU. + + + An application identifies the way a resource is intended to be used (its usage) in a resource description. There are several structures for creating resources including: , , , , and . Differences between Direct3D 9 and Direct3D 10: In Direct3D 9, you specify the type of memory a resource should be created in at resource creation time (using D3DPOOL). It was an application's job to decide what memory pool would provide the best combination of functionality and performance. In Direct3D 10, an application no longer specifies what type of memory (the pool) to create a resource in. Instead, you specify the intended usage of the resource, and let the runtime (in concert with the driver and a memory manager) choose the type of memory that will achieve the best performance. ? Resource Usage Restrictions Each usage dictates a tradeoff between functionality and performance. In general, resource accessing is accomplished with the following APIs. CPU access is done with , , , or GPU access is done with {{CopySubresourceRegion}}, {{CopyResource}}, or {{UpdateSubresource}}. Use the following table to choose the usage that best describes how the resource will need to be accessed by the CPU and/or the GPU. Of course, there will be performance tradeoffs. Resource UsageDefaultDynamicImmutableStaging GPU-Readyesyes1yesyes1, 2 GPU-Writeyes1yes1, 2 CPU-Readyes1, 2 CPU-Writeyesyes1, 2 ? 1 - This is restricted to {{CopySubresourceRegion}} and {{CopyResource}}. 2 - Cannot be a depth-stencil buffer or a multisampled render target. Resource Bind Options To maximize performance, not all resource usage options can be used as input or output resources to the pipeline. This table identifies these limitations. Resource Can Be Bound AsDefaultDynamicImmutableStaging Input to a Stageyes3yes4yes Output from a Stageyes3 ? 3 - If bound as an input and an output using different views, each view must use different {{subresources}}. 4 - The resource can only be created with a single {{subresource}}. The resource cannot be a texture array. The resource cannot be a mipmap chain. + + D3D10_USAGE + + + + A resource that requires read and write access by the GPU. This is likely to be the most common usage choice. + + D3D10_USAGE_DEFAULT + + + + A resource that can only be read by the GPU. It cannot be written by the GPU, and cannot be accessed at all by the CPU. This type of resource must be initialized when it is created, since it cannot be changed after creation. + + D3D10_USAGE_IMMUTABLE + + + + A resource that is accessible by both the GPU and the CPU (write only). A dynamic resource is a good choice for a resource that will be updated by the CPU at least once per frame. To write to a dynamic resource on the CPU, use a Map method. You can write to a dynamic resource on the GPU using {{CopyResource}} or {{CopySubresourceRegion}}. + + D3D10_USAGE_DYNAMIC + + + + A resource that supports data transfer (copy) from the GPU to the CPU. + + D3D10_USAGE_STAGING + + + + Identifies how to bind a resource to the pipeline. + + + In general, binding flags can be combined using a logical OR (except the constant-buffer flag); however, you should use a single flag to allow the device to optimize the resource usage. This enumeration is used by a: {{Buffer description}} when creating a buffer. Texture description when creating a texture (see or or ). A shader-resource buffer is NOT a constant buffer; rather, it is a texture or buffer resource that is bound to a shader, that contains texture or buffer data (it is not limited to a single element type in the buffer). A shader-resource buffer is created with the D3D10_BIND_SHADER_RESOURCE flag and is bound to the pipeline using one of these APIs: , , or . Furthermore, a shader-resource buffer cannot use the flag. + + D3D10_BIND_FLAG + + + + Bind a buffer as a {{vertex buffer}} to the {{input-assembler stage}}. + + D3D10_BIND_VERTEX_BUFFER + + + + Bind a buffer as an {{index buffer}} to the {{input-assembler stage}}. + + D3D10_BIND_INDEX_BUFFER + + + + Bind a buffer as a {{constant buffer}} to a {{shader stage}}; this flag may NOT be combined with any other bind flag. + + D3D10_BIND_CONSTANT_BUFFER + + + + Bind a buffer or texture to a {{shader stage}}; this flag cannot be used with the flag. + + D3D10_BIND_SHADER_RESOURCE + + + + Bind an output buffer for the {{stream-output stage}}. + + D3D10_BIND_STREAM_OUTPUT + + + + Bind a texture as a render target for the {{output-merger stage}}. + + D3D10_BIND_RENDER_TARGET + + + + Bind a texture as a depth-stencil target for the {{output-merger stage}}. + + D3D10_BIND_DEPTH_STENCIL + + + + None. + + None + + + + Specifies the types of CPU access allowed for a resource. + + + This enumeration is used in , , , , and . See {{Creating Buffer Resources (Direct3D 10)}} for more details. Applications may combine one or more of these flags with a logical OR. When possible, create resources with no CPU access flags, as this enables better resource optimiztion. + + D3D10_CPU_ACCESS_FLAG + + + + The resource is to be {{mappable}} so that the CPU can change its contents. Resources created with this flag cannot be set as outputs of the pipeline and must be created with either dynamic or staging usage (see ). + + D3D10_CPU_ACCESS_WRITE + + + + The resource is to be {{mappable}} so that the CPU can read its contents. Resources created with this flag cannot be set as either inputs or outputs to the pipeline and must be created with staging usage (see ). + + D3D10_CPU_ACCESS_READ + + + + None. + + None + + + + Identifies other, less common options for resources. + + + This enumeration is used in , , , , , and . These flags can be combined by bitwise OR. D3D10_RESOURCE_MISC_SHARED and D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX are mutually exclusive flags: either one may be set in the resource creation calls but not both simultaneously. + + D3D10_RESOURCE_MISC_FLAG + + + + Enables an application to call on a {{texture resource}}. The resource must be created with the {{bind flags}} that specify that the resource is a render target and a shader resource. + + D3D10_RESOURCE_MISC_GENERATE_MIPS + + + + Enables the sharing of resource data between two or more Direct3D devices. The only resources that can be shared are 2D non-mipmapped textures. WARP and REF devices do not support shared resources. Attempting to create a resource with this flag on either a WARP or REF device will cause the create method to return an E_OUTOFMEMORY error code. + + D3D10_RESOURCE_MISC_SHARED + + + + Enables an application to create a cube texture from a {{Texture2DArray}} that contains 6 textures. + + D3D10_RESOURCE_MISC_TEXTURECUBE + + + + Enables the resource created to be synchronized using the IDXGIKeyedMutex::AcquireSync and ReleaseSync APIs. The following resource creation D3D10 APIs, that all take a D3D10_RESOURCE_MISC_FLAG parameter, have been extended to support the new flag. ID3D10Device1::CreateTexture1D ID3D10Device1::CreateTexture2D ID3D10Device1::CreateTexture3D ID3D10Device1::CreateBuffer If any of the listed functions are called with the D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX flag set, the interface returned can be queried for an IDXGIKeyedMutex interface, which implements AcquireSync and ReleaseSync APIs to synchronize access to the surface. The device creating the surface, and any other device opening the surface (using OpenSharedResource) is required to call IDXGIKeyedMutex::AcquireSync before any rendering commands to the surface, and IDXGIKeyedMutex::ReleaseSync when it is done rendering. WARP and REF devices do not support shared resources. Attempting to create a resource with this flag on either a WARP or REF device will cause the create method to return an E_OUTOFMEMORY error code. + + D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX + + + + Enables a surface to be used for GDI interoperability. Setting this flag enables rendering on the surface via IDXGISurface1::GetDC. + + D3D10_RESOURCE_MISC_GDI_COMPATIBLE + + + + None. + + None + + + + Identifies a resource to be accessed for reading and writing by the CPU. Applications may combine one or more of these flags. + + + This enumeration is used in , , , and . These remarks are divided into the following topics: {{Meaning of D3D10_MAP_WRITE_NO_OVERWRITE}} {{Common Usage of D3D10_MAP_WRITE_DISCARD with D3D10_MAP_WRITE_NO_OVERWRITE}} Meaning of D3D10_MAP_WRITE_NO_OVERWRITE D3D10_MAP_WRITE_NO_OVERWRITE signifies that the application promises not to write to data that the {{Input Assembler}} (IA) stage is using. In exchange, the GPU allows the application to write to other parts of the same buffer. The application must ensure that it does not write over any data in use by the IA stage. For example, consider the buffer illustrated in the following diagram. If a Draw call has been issued that uses vertices 4-6, an application that calls Map on this buffer must ensure that it does not write to the vertices that the Draw call will access during rendering. ? Diagram of vertex data in different stages of utilization ? However, ensuring this can be difficult, because the GPU is often many frames behind the CPU in terms of which frame it is currently processing. Keeping track of which sections of a resource are being used because of calls made 2 to 5 frames ago is difficult and error-prone. Because of this, it is recommended that applications only write to the uninitialized portions of a resource when using D3D10_MAP_WRITE_NO_OVERWRITE. Common Usage of D3D10_MAP_WRITE_DISCARD with D3D10_MAP_WRITE_NO_OVERWRITE D3D10_MAP_WRITE_DISCARD and D3D10_MAP_WRITE_NO_OVERWRITE are normally used in conjunction with dynamic index/vertex buffers, although they can also be used with dynamic textures. A common use of these two flags involves filling dynamic index/vertex buffers with geometry that can be seen from the camera's current position. The first time that data is entered into the buffer on a given frame, Map is called with D3D10_MAP_WRITE_DISCARD; doing so invalidates the previous contents of the buffer. The buffer is then filled with all available data. Subsequent writes to the buffer within the same frame should use D3D10_MAP_WRITE_NO_OVERWRITE. This will enable the CPU to access a resource that is potentially being used by the GPU as long as the restrictions described previously are respected. + + D3D10_MAP + + + + Resource is mapped for reading. The resource must have been created with read access (see ). + + D3D10_MAP_READ + + + + Resource is mapped for writing. The resource must have been created with write access (see ). + + D3D10_MAP_WRITE + + + + Resource is mapped for reading and writing. The resource must have been created with read and write access (see {{D3D10_CPU_ACCESS_READ and D3D10_CPU_ACCESS_WRITE}}). + + D3D10_MAP_READ_WRITE + + + + Resource is mapped for writing; the previous contents of the resource will be undefined. The resource must have been created with write access (see ). + + D3D10_MAP_WRITE_DISCARD + + + + Resource is mapped for writing; the existing contents of the resource cannot be overwritten (see Remarks). This flag is only valid on vertex and index buffers. The resource must have been created with write access (see ). Cannot be used on a resource created with the flag. + + D3D10_MAP_WRITE_NO_OVERWRITE + + + + Specifies how the CPU should respond when Map is called on a resource being used by the GPU. + + + This enumeration is used by , , , and . D3D10_MAP_FLAG_DO_NOT_WAIT cannot be used with or {{D3D10_MAP_WRITE_NOOVERWRITE}}. For more information about potential conflicts between the GPU and CPU during resource mapping, see {{Copying and Accessing Resource Data (Direct3D 10)}}. + + D3D10_MAP_FLAG + + + + Specifies that Map should return DXGI_ERROR_WAS_STILL_DRAWING when the GPU blocks the CPU from accessing a resource. + + D3D10_MAP_FLAG_DO_NOT_WAIT + + + + None. + + None + + + + Specifies the parts of the depth stencil to clear. Usually used with . + + + These flags can be bitwise ORed together. + + D3D10_CLEAR_FLAG + + + + Clear the depth buffer. + + D3D10_CLEAR_DEPTH + + + + Clear the stencil buffer. + + D3D10_CLEAR_STENCIL + + + + Comparison options. + + + A comparison option determines whether how the runtime compares source (new) data against destination (existing) data before storing the new data. The comparison option is declared in a description before an object is created. The API allows you to set a comparison option for a depth-stencil buffer (see ), depth-stencil operations (see ), or sampler state (see ). + + D3D10_COMPARISON_FUNC + + + + Never pass the comparison. + + D3D10_COMPARISON_NEVER + + + + If the source data is less than the destination data, the comparison passes. + + D3D10_COMPARISON_LESS + + + + If the source data is equal to the destination data, the comparison passes. + + D3D10_COMPARISON_EQUAL + + + + If the source data is less than or equal to the destination data, the comparison passes. + + D3D10_COMPARISON_LESS_EQUAL + + + + If the source data is greater than the destination data, the comparison passes. + + D3D10_COMPARISON_GREATER + + + + If the source data is not equal to the destination data, the comparison passes. + + D3D10_COMPARISON_NOT_EQUAL + + + + If the source data is greater than or equal to the destination data, the comparison passes. + + D3D10_COMPARISON_GREATER_EQUAL + + + + Always pass the comparison. + + D3D10_COMPARISON_ALWAYS + + + + Identify the portion of a {{depth-stencil}} buffer for writing depth data. + + D3D10_DEPTH_WRITE_MASK + + + + Turn off writes to the depth-stencil buffer. + + D3D10_DEPTH_WRITE_MASK_ZERO + + + + Turn on writes to the depth-stencil buffer. + + D3D10_DEPTH_WRITE_MASK_ALL + + + + The stencil operations that can be performed during {{depth-stencil}} testing. + + D3D10_STENCIL_OP + + + + Keep the existing stencil data. + + D3D10_STENCIL_OP_KEEP + + + + Set the stencil data to 0. + + D3D10_STENCIL_OP_ZERO + + + + Set the stencil data to the reference value set by calling . + + D3D10_STENCIL_OP_REPLACE + + + + Increment the stencil value by 1, and clamp the result. + + D3D10_STENCIL_OP_INCR_SAT + + + + Decrement the stencil value by 1, and clamp the result. + + D3D10_STENCIL_OP_DECR_SAT + + + + Invert the stencil data. + + D3D10_STENCIL_OP_INVERT + + + + Increment the stencil value by 1, and wrap the result if necessary. + + D3D10_STENCIL_OP_INCR + + + + Increment the stencil value by 1, and wrap the result if necessary. + + D3D10_STENCIL_OP_DECR + + + + Blend options. A blend option identifies the data source and an optional pre-blend operation. + + + Blend operations are specified in a {{blend description}}. + + D3D10_BLEND + + + + The data source is the color black (0, 0, 0, 0). No pre-blend operation. + + D3D10_BLEND_ZERO + + + + The data source is the color white (1, 1, 1, 1). No pre-blend operation. + + D3D10_BLEND_ONE + + + + The data source is color data (RGB) from a pixel shader. No pre-blend operation. + + D3D10_BLEND_SRC_COLOR + + + + The data source is color data (RGB) from a pixel shader. The pre-blend operation inverts the data, generating 1 - RGB. + + D3D10_BLEND_INV_SRC_COLOR + + + + The data source is alpha data (A) from a pixel shader. No pre-blend operation. + + D3D10_BLEND_SRC_ALPHA + + + + The data source is alpha data (A) from a pixel shader. The pre-blend operation inverts the data, generating 1 - A. + + D3D10_BLEND_INV_SRC_ALPHA + + + + The data source is alpha data from a rendertarget. No pre-blend operation. + + D3D10_BLEND_DEST_ALPHA + + + + The data source is alpha data from a rendertarget. The pre-blend operation inverts the data, generating 1 - A. + + D3D10_BLEND_INV_DEST_ALPHA + + + + The data source is color data from a rendertarget. No pre-blend operation. + + D3D10_BLEND_DEST_COLOR + + + + The data source is color data from a rendertarget. The pre-blend operation inverts the data, generating 1 - RGB. + + D3D10_BLEND_INV_DEST_COLOR + + + + The data source is alpha data from a pixel shader. The pre-blend operation clamps the data to 1 or less. + + + D3D10_BLEND_SRC_ALPHA_SAT + + + + The data source is the blend factor set with . No pre-blend operation. + + D3D10_BLEND_BLEND_FACTOR + + + + The data source is the blend factor set with . The pre-blend operation inverts the blend factor, generating 1 - blend_factor. + + D3D10_BLEND_INV_BLEND_FACTOR + + + + The data sources are both color data output by a pixel shader. There is no pre-blend operation. This options supports {{dual-source color blending}}. + + D3D10_BLEND_SRC1_COLOR + + + + The data sources are both color data output by a pixel shader. The pre-blend operation inverts the data, generating 1 - RGB. This options supports {{dual-source color blending}}. + + D3D10_BLEND_INV_SRC1_COLOR + + + + The data sources are alpha data output by a pixel shader. There is no pre-blend operation. This options supports {{dual-source color blending}}. + + D3D10_BLEND_SRC1_ALPHA + + + + The data sources are alpha data output by a pixel shader. The pre-blend operation inverts the data, generating 1 - A. This options supports {{dual-source color blending}}. + + D3D10_BLEND_INV_SRC1_ALPHA + + + + RGB or alpha blending operation. + + + The runtime implements RGB blending and alpha blending separately. Therefore, blend state requires separate blend operations for RGB data and alpha data. These blend operations are specified in a {{blend description}}. The two sources ? Source 1, called SrcBlend and SrcBlendAlpha, and Source 2, called DestBlend and DestBlendAlpha ? are shown in the {{blending block diagram}}. + + D3D10_BLEND_OP + + + + Add source 1 and source 2. + + D3D10_BLEND_OP_ADD + + + + Subtract source 1 from source 2. + + D3D10_BLEND_OP_SUBTRACT + + + + Subtract source 2 from source 1. + + D3D10_BLEND_OP_REV_SUBTRACT + + + + Find the minimum of source 1 and source 2. + + D3D10_BLEND_OP_MIN + + + + Find the maximum of source 1 and source 2. + + D3D10_BLEND_OP_MAX + + + + Identify which components of each pixel of a render target are writable during {{blending}}. + + + These flags can be combined with a bitwise OR. + + D3D10_COLOR_WRITE_ENABLE + + + + Allow data to be stored in the red component. + + D3D10_COLOR_WRITE_ENABLE_RED + + + + Allow data to be stored in the green component. + + D3D10_COLOR_WRITE_ENABLE_GREEN + + + + Allow data to be stored in the blue component. + + D3D10_COLOR_WRITE_ENABLE_BLUE + + + + Allow data to be stored in the alpha component. + + D3D10_COLOR_WRITE_ENABLE_ALPHA + + + + Allow data to be stored in all components. + + D3D10_COLOR_WRITE_ENABLE_ALL + + + + The different faces of a cube texture. + + D3D10_TEXTURECUBE_FACE + + + + Positive X face. + + D3D10_TEXTURECUBE_FACE_POSITIVE_X + + + + Negative X face. + + D3D10_TEXTURECUBE_FACE_NEGATIVE_X + + + + Positive Y face. + + D3D10_TEXTURECUBE_FACE_POSITIVE_Y + + + + Negative Y face. + + D3D10_TEXTURECUBE_FACE_NEGATIVE_Y + + + + Positive Z face. + + D3D10_TEXTURECUBE_FACE_POSITIVE_Z + + + + Negative Z face. + + D3D10_TEXTURECUBE_FACE_NEGATIVE_Z + + + + Filtering options during texture sampling. + + + During texture sampling, one or more texels are read and combined (this is calling filtering) to produce a single value. Point sampling reads a single texel while linear sampling reads two texels (endpoints) and linearly interpolates a third value between the endpoints. HLSL texture-sampling functions also support comparison filtering during texture sampling. Comparison filtering compares each sampled texel against a comparison value. The boolean result is blended the same way that normal texture filtering is blended. You can use HLSL intrinsic texture-sampling functions that implement texture filtering only or companion functions that use texture filtering with comparison filtering. Texture Sampling FunctionTexture Sampling Function with Comparison Filtering {{sample}} {{samplecmp}} or {{samplecmplevelzero}} ? Comparison filters only work with textures that have the following {{formats}}: R32_FLOAT_X8X24_TYPELESS, R32_FLOAT, R24_UNORM_X8_TYPELESS, R16_UNORM. + + D3D10_FILTER + + + + Use point sampling for minification, magnification, and mip-level sampling. + + D3D10_FILTER_MIN_MAG_MIP_POINT + + + + Use point sampling for minification and magnification; use linear interpolation for mip-level sampling. + + D3D10_FILTER_MIN_MAG_POINT_MIP_LINEAR + + + + Use point sampling for minification; use linear interpolation for magnification; use point sampling for mip-level sampling. + + D3D10_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT + + + + Use point sampling for minification; use linear interpolation for magnification and mip-level sampling. + + D3D10_FILTER_MIN_POINT_MAG_MIP_LINEAR + + + + Use linear interpolation for minification; use point sampling for magnification and mip-level sampling. + + D3D10_FILTER_MIN_LINEAR_MAG_MIP_POINT + + + + Use linear interpolation for minification; use point sampling for magnification; use linear interpolation for mip-level sampling. + + D3D10_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR + + + + Use linear interpolation for minification and magnification; use point sampling for mip-level sampling. + + D3D10_FILTER_MIN_MAG_LINEAR_MIP_POINT + + + + Use linear interpolation for minification, magnification, and mip-level sampling. + + D3D10_FILTER_MIN_MAG_MIP_LINEAR + + + + Use anisotropic interpolation for minification, magnification, and mip-level sampling. + + D3D10_FILTER_ANISOTROPIC + + + + Use point sampling for minification, magnification, and mip-level sampling. Compare the result to the comparison value. + + D3D10_FILTER_COMPARISON_MIN_MAG_MIP_POINT + + + + Use point sampling for minification and magnification; use linear interpolation for mip-level sampling. Compare the result to the comparison value. + + D3D10_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR + + + + Use point sampling for minification; use linear interpolation for magnification; use point sampling for mip-level sampling. Compare the result to the comparison value. + + D3D10_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT + + + + Use point sampling for minification; use linear interpolation for magnification and mip-level sampling. Compare the result to the comparison value. + + D3D10_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR + + + + Use linear interpolation for minification; use point sampling for magnification and mip-level sampling. Compare the result to the comparison value. + + D3D10_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT + + + + Use linear interpolation for minification; use point sampling for magnification; use linear interpolation for mip-level sampling. Compare the result to the comparison value. + + D3D10_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR + + + + Use linear interpolation for minification and magnification; use point sampling for mip-level sampling. Compare the result to the comparison value. + + D3D10_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT + + + + Use linear interpolation for minification, magnification, and mip-level sampling. Compare the result to the comparison value. + + D3D10_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR + + + + Use anisotropic interpolation for minification, magnification, and mip-level sampling. Compare the result to the comparison value. + + D3D10_FILTER_COMPARISON_ANISOTROPIC + + + + For use in pixel shaders with textures that have the R1_UNORM format. + + D3D10_FILTER_TEXT_1BIT + + + + Types of magnification or minification sampler filters. + + D3D10_FILTER_TYPE + + + + Point filtering used as a texture magnification or minification filter. The texel with coordinates nearest to the desired pixel value is used. The texture filter to be used between mipmap levels is nearest-point mipmap filtering. The rasterizer uses the color from the texel of the nearest mipmap texture. + + D3D10_FILTER_TYPE_POINT + + + + Bilinear interpolation filtering used as a texture magnification or minification filter. A weighted average of a 2 x 2 area of texels surrounding the desired pixel is used. The texture filter to use between mipmap levels is trilinear mipmap interpolation. The rasterizer linearly interpolates pixel color, using the texels of the two nearest mipmap textures. + + D3D10_FILTER_TYPE_LINEAR + + + + Identify a technique for resolving texture coordinates that are outside of the boundaries of a texture. + + D3D10_TEXTURE_ADDRESS_MODE + + + + Tile the texture at every integer junction. For example, for u values between 0 and 3, the texture is repeated three times. + + D3D10_TEXTURE_ADDRESS_WRAP + + + + Flip the texture at every integer junction. For u values between 0 and 1, for example, the texture is addressed normally; between 1 and 2, the texture is flipped (mirrored); between 2 and 3, the texture is normal again; and so on. + + D3D10_TEXTURE_ADDRESS_MIRROR + + + + Texture coordinates outside the range [0.0, 1.0] are set to the texture color at 0.0 or 1.0, respectively. + + D3D10_TEXTURE_ADDRESS_CLAMP + + + + Texture coordinates outside the range [0.0, 1.0] are set to the border color specified in or HLSL code. + + D3D10_TEXTURE_ADDRESS_BORDER + + + + Similar to D3D10_TEXTURE_ADDRESS_MIRROR and D3D10_TEXTURE_ADDRESS_CLAMP. Takes the absolute value of the texture coordinate (thus, mirroring around 0), and then clamps to the maximum value. + + D3D10_TEXTURE_ADDRESS_MIRROR_ONCE + + + + Which resources are supported for a given format and given device (see ). + + D3D10_FORMAT_SUPPORT + + + + Buffer resources supported. + + D3D10_FORMAT_SUPPORT_BUFFER + + + + Vertex buffers supported. + + D3D10_FORMAT_SUPPORT_IA_VERTEX_BUFFER + + + + Index buffers supported. + + D3D10_FORMAT_SUPPORT_IA_INDEX_BUFFER + + + + Streaming output buffers supported. + + D3D10_FORMAT_SUPPORT_SO_BUFFER + + + + 1D texture resources supported. + + D3D10_FORMAT_SUPPORT_TEXTURE1D + + + + 2D texture resources supported. + + D3D10_FORMAT_SUPPORT_TEXTURE2D + + + + 3D texture resources supported. + + D3D10_FORMAT_SUPPORT_TEXTURE3D + + + + Cube texture resources supported. + + D3D10_FORMAT_SUPPORT_TEXTURECUBE + + + + The intrinsic HLSL function {{load}} is supported. + + D3D10_FORMAT_SUPPORT_SHADER_LOAD + + + + The intrinsic HLSL functions {{Sample}} supported. + + D3D10_FORMAT_SUPPORT_SHADER_SAMPLE + + + + The intrinsic HLSL functions {{SampleCmp}} and {{SampleCmpLevelZero}} are supported. + + D3D10_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON + + + + Reserved. + + D3D10_FORMAT_SUPPORT_SHADER_SAMPLE_MONO_TEXT + + + + Mipmaps are supported. + + D3D10_FORMAT_SUPPORT_MIP + + + + Automatic generation of mipmaps is supported. + + D3D10_FORMAT_SUPPORT_MIP_AUTOGEN + + + + Rendertargets are supported. + + D3D10_FORMAT_SUPPORT_RENDER_TARGET + + + + Render target blend operations supported. + + D3D10_FORMAT_SUPPORT_BLENDABLE + + + + Depth stencils supported. + + D3D10_FORMAT_SUPPORT_DEPTH_STENCIL + + + + CPU locking supported. + + D3D10_FORMAT_SUPPORT_CPU_LOCKABLE + + + + Multisampling resolution supported. + + D3D10_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE + + + + Format can be displayed on screen. + + D3D10_FORMAT_SUPPORT_DISPLAY + + + + Format cannot be cast to another format. + + D3D10_FORMAT_SUPPORT_CAST_WITHIN_BIT_LAYOUT + + + + Format can be used as a multisampled rendertarget. + + D3D10_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET + + + + Format can be used as a multisampled texture and read into a shader with the {{load}} function. + + D3D10_FORMAT_SUPPORT_MULTISAMPLE_LOAD + + + + Format can be used with the {{gather}} function. This value is available in DirectX 10.1 or higher. + + D3D10_FORMAT_SUPPORT_SHADER_GATHER + + + + No documentation. + + D3D10_FORMAT_SUPPORT_BACK_BUFFER_CAST + + + + Optional flags that control the behavior of . + + D3D10_ASYNC_GETDATA_FLAG + + + + Do not flush the command buffer. This can potentially cause an infinite loop if GetData is continually called until it returns S_OK as there may still be commands in the command buffer that need to be processed in order for GetData to return S_OK. Since the commands in the command buffer are not flushed they will not be processed and therefore GetData will never return S_OK. + + D3D10_ASYNC_GETDATA_DONOTFLUSH + + + + None. + + None + + + + Query types. + + D3D10_QUERY + + + + Determines whether or not the GPU is finished processing commands. When the GPU is finished processing commands {{GetData}} will return S_OK, and pData will point to a BOOL with a value of TRUE. When using this type of query, {{Begin}} is disabled. + + D3D10_QUERY_EVENT + + + + Get the number of samples that passed the depth and stencil tests in between {{Begin}} and {{End}}. {{GetData}} returns a UINT64. If a depth or stencil test is disabled, then each of those tests will be counted as a pass. + + D3D10_QUERY_OCCLUSION + + + + Get a timestamp value where {{GetData}} returns a UINT64. This kind of query is only useful if two timestamp queries are done in the middle of a D3D10_QUERY_TIMESTAMP_DISJOINT query. The difference of two timestamps can be used to determine how many ticks have elapsed, and the D3D10_QUERY_TIMESTAMP_DISJOINT query will determine if that difference is a reliable value and also has a value that shows how to convert the number of ticks into seconds. See . When using this type of query, {{Begin}} is disabled. + + D3D10_QUERY_TIMESTAMP + + + + Determines whether or not a D3D10_QUERY_TIMESTAMP is returning reliable values, and also gives the frequency of the processor enabling you to convert the number of elapsed ticks into seconds. {{GetData}} will return a . This type of query should only be invoked once per frame or less. + + D3D10_QUERY_TIMESTAMP_DISJOINT + + + + Get pipeline statistics, such as the number of pixel shader invocations in between {{Begin}} and {{End}}. {{GetData}} will return a . + + D3D10_QUERY_PIPELINE_STATISTICS + + + + Similar to D3D10_QUERY_OCCLUSION, except {{GetData}} returns a BOOL indicating whether or not any samples passed the depth and stencil tests - TRUE meaning at least one passed, FALSE meaning none passed. + + D3D10_QUERY_OCCLUSION_PREDICATE + + + + Get streaming output statistics, such as the number of primitives streamed out in between {{Begin}} and {{End}}. {{GetData}} will return a structure. + + D3D10_QUERY_SO_STATISTICS + + + + Determines whether or not any of the streaming output buffers overflowed in between {{Begin}} and {{End}}. {{GetData}} returns a BOOL - TRUE meaning there was an overflow, FALSE meaning there was not an overflow. If streaming output writes to multiple buffers, and one of the buffers overflows, then it will stop writing to all the output buffers. When an overflow is detected by Direct3D it is prevented from happening - no memory is corrupted. This predication may be used in conjunction with an SO_STATISTICS query so that when an overflow occurs the SO_STATISTIC query will let the application know how much memory was needed to prevent an overflow. + + D3D10_QUERY_SO_OVERFLOW_PREDICATE + + + + Flags that describe miscellaneous query behavior. + + + This flag is part of a query description (see ). + + D3D10_QUERY_MISC_FLAG + + + + Tell the hardware that if it is not yet sure if something is hidden or not to draw it anyway. This is only used with an occlusion predicate. Predication data cannot be returned to your application via when using this flag. + + D3D10_QUERY_MISC_PREDICATEHINT + + + + None. + + None + + + + Performance counter types. + + + In addition to these performance counters, independent hardware vendors may define their own set of performance counters for their devices. The enum values for these counters would start after D3D10_COUNTER_DEVICE_DEPENDENT_0 and would be defined by those hardware vendors. + + D3D10_COUNTER + + + + Percentage of the time that the GPU is idle. + + D3D10_COUNTER_GPU_IDLE + + + + Percentage of the time that the GPU does vertex processing. + + D3D10_COUNTER_VERTEX_PROCESSING + + + + Percentage of the time that the GPU does geometry processing. + + D3D10_COUNTER_GEOMETRY_PROCESSING + + + + Percentage of the time that the GPU does pixel processing. + + D3D10_COUNTER_PIXEL_PROCESSING + + + + Percentage of the time that the GPU does other processing (not vertex, geometry, or pixel processing). + + D3D10_COUNTER_OTHER_GPU_PROCESSING + + + + Percentage of bandwidth used on a host adapter. Value returned by between 0.0 and 1.0 when using this counter. + + D3D10_COUNTER_HOST_ADAPTER_BANDWIDTH_UTILIZATION + + + + Percentage of bandwidth used by the local video memory. Value returned by between 0.0 and 1.0 when using this counter + + D3D10_COUNTER_LOCAL_VIDMEM_BANDWIDTH_UTILIZATION + + + + Percentage of throughput used for vertices. Value returned by between 0.0 and 1.0 when using this counter + + D3D10_COUNTER_VERTEX_THROUGHPUT_UTILIZATION + + + + Percentage of throughput used for triangle setup. Value returned by between 0.0 and 1.0 when using this counter + + D3D10_COUNTER_TRIANGLE_SETUP_THROUGHPUT_UTILIZATION + + + + Percentage of throughput used for the fillrate. Value returned by between 0.0 and 1.0 when using this counter. + + D3D10_COUNTER_FILLRATE_THROUGHPUT_UTILIZATION + + + + Percentage of time that a vertex shader spends sampling resources. + + D3D10_COUNTER_VS_MEMORY_LIMITED + + + + Percentage of time that a vertex shader spends doing computations. + + D3D10_COUNTER_VS_COMPUTATION_LIMITED + + + + Percentage of time that a geometry shader spends sampling resources. + + D3D10_COUNTER_GS_MEMORY_LIMITED + + + + Percentage of time that a geometry shader spends doing computations. + + D3D10_COUNTER_GS_COMPUTATION_LIMITED + + + + Percentage of time that a pixel shader spends sampling resources. + + D3D10_COUNTER_PS_MEMORY_LIMITED + + + + Percentage of time that a pixel shader spends doing computations. + + D3D10_COUNTER_PS_COMPUTATION_LIMITED + + + + Percentage of vertex data that was read from the vertex cache. For example, if 6 vertices were added to the cache and 3 of them were read from the cache, then the hit rate would be 0.5. + + D3D10_COUNTER_POST_TRANSFORM_CACHE_HIT_RATE + + + + Percentage of texel data that was read from the vertex cache. For example, if 6 texels were added to the cache and 3 of them were read from the cache, then the hit rate would be 0.5. + + D3D10_COUNTER_TEXTURE_CACHE_HIT_RATE + + + + Start of the device-dependent counters. See remarks. + + D3D10_COUNTER_DEVICE_DEPENDENT_0 + + + + Data type of a performance counter. + + + These flags are an output parameter in . + + D3D10_COUNTER_TYPE + + + + 32-bit floating point. + + D3D10_COUNTER_TYPE_FLOAT32 + + + + 16-bit unsigned integer. + + D3D10_COUNTER_TYPE_UINT16 + + + + 32-bit unsigned integer. + + D3D10_COUNTER_TYPE_UINT32 + + + + 64-bit unsigned integer. + + D3D10_COUNTER_TYPE_UINT64 + + + + Device creation flags. + + + Device creation flags are used by and . An application might dynamically create (and destroy) threads to improve performance especially on a machine with multiple CPU cores. There may be cases, however, when an application needs to prevent extra threads from being created. This can happen when you want to simplify debugging, profile code or develop a tool for instance. For these cases, use D3D10_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS to request that the runtime and video driver not create any additional threads that might interfere with the application. + + D3D10_CREATE_DEVICE_FLAG + + + + Use this flag if an application will only be calling D3D10 from a single thread. If this flag is not specified, the default behavior of D3D10 is to enter a lock during each API call to prevent multiple threads altering internal state. By using this flag no locks will be taken which can slightly increase performance, but could result in undefine behavior if D3D10 is called from multiple threads. + + D3D10_CREATE_DEVICE_SINGLETHREADED + + + + Create a device that supports the {{debug layer}}. + + D3D10_CREATE_DEVICE_DEBUG + + + + Create both a software (REF) and hardware (HAL) version of the device simultaneously, which allows an application to switch to a reference device to enable debugging. See for more information. + + D3D10_CREATE_DEVICE_SWITCH_TO_REF + + + + Prevents multiple threads from being created. When this flag is used with a WARP device, no additional threads will be created by WARP and all rasterization will occur on the calling thread. This flag is not recommended for general use. See remarks. + + D3D10_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS + + + + Return a NULL reference instead of triggering an exception on memory exhaustion during invocations to Map. Without this flag an exception will be raised on memory exhaustion. Only valid on Winodws 7. + + D3D10_CREATE_DEVICE_ALLOW_NULL_FROM_MAP + + + + Causes device creation to fail if BGRA support is not available. BGRA support enables the following formats. DXGI_FORMAT_B8G8R8A8_TYPELESS DXGI_FORMAT_B8G8R8A8_UNORM DXGI_FORMAT_B8G8R8A8_UNORM_SRGB DXGI_FORMAT_B8G8R8X8_TYPELESS DXGI_FORMAT_B8G8R8X8_UNORM DXGI_FORMAT_B8G8R8X8_UNORM_SRGB D3D10_CREATE_DEVICE_BGRA_SUPPORT is only relevant when a device is created with or using the D3D10_FEATURE_LEVEL_10_0 or D3D10_FEATURE_LEVEL_10_1 feature levels, the flag will be ignored when a device is created with other feature levels. Note that BGRA support may be present even if the application didn't specify D3D10_CREATE_DEVICE_BGRA_SUPPORT. The flag merely causes device creation to fail if BGRA support isn't available. D3D10_CREATE_DEVICE_BGRA_SUPPORT is only valid on Windows 7, Windows Server 2008 R2, and updated Windows Vista (KB971644) systems. + + D3D10_CREATE_DEVICE_BGRA_SUPPORT + + + + Reserved. This flag is currently not supported. Do not use. + + D3D10_CREATE_DEVICE_STRICT_VALIDATION + + + + None. + + None + + + + No documentation. + + D3D10_DEBUG_FEATURE_FLAGS + + + + No documentation. + + D3D10_DEBUG_FEATURE_FLUSH_PER_RENDER_OP + + + + No documentation. + + D3D10_DEBUG_FEATURE_FINISH_PER_RENDER_OP + + + + No documentation. + + D3D10_DEBUG_FEATURE_PRESENT_PER_RENDER_OP + + + + The device-driver type. + + + The device-driver type needs to be specified when the device is created (using or ). For information about limitations creating nonhardware-type devices on certain feature levels, see {{Limitations Creating WARP and Reference Devices}}. + + D3D10_DRIVER_TYPE + + + + A hardware device; commonly called a HAL device. + + D3D10_DRIVER_TYPE_HARDWARE + + + + A reference device; commonly called a REF device. + + D3D10_DRIVER_TYPE_REFERENCE + + + + A NULL device; which is a reference device without render capability. + + D3D10_DRIVER_TYPE_NULL + + + + Reserved for later use. + + D3D10_DRIVER_TYPE_SOFTWARE + + + + A WARP driver, which is a high-performance software rasterizer. The rasterizer supports feature level 9_1 through level 10.1 with a high performance software implementation when hardware is not available. For more information about using a WARP driver, see {{Windows Advanced Rasterization Platform (WARP) In-Depth Guide}}. Note that WARP is only available with the DirectX 11 Runtime (Windows 7, Windows Server 2008 R2, updated Windows Vista [KB971644]). + + D3D10_DRIVER_TYPE_WARP + + + + Effect device-state types. + + + This enumeration is used by , , and . + + D3D10_DEVICE_STATE_TYPES + + + + Stream-output buffer. + + D3D10_DST_SO_BUFFERS + + + + Render target. + + D3D10_DST_OM_RENDER_TARGETS + + + + Depth-stencil state. + + D3D10_DST_OM_DEPTH_STENCIL_STATE + + + + Blend state. + + D3D10_DST_OM_BLEND_STATE + + + + Vertex shader. + + D3D10_DST_VS + + + + Vertex shader sampler. + + D3D10_DST_VS_SAMPLERS + + + + Vertex shader resource. + + D3D10_DST_VS_SHADER_RESOURCES + + + + Vertex shader constant buffer. + + D3D10_DST_VS_CONSTANT_BUFFERS + + + + Geometry shader. + + D3D10_DST_GS + + + + Geometry shader sampler. + + D3D10_DST_GS_SAMPLERS + + + + Geometry shader resource. + + D3D10_DST_GS_SHADER_RESOURCES + + + + Geometry shader constant buffer. + + D3D10_DST_GS_CONSTANT_BUFFERS + + + + Pixel shader. + + D3D10_DST_PS + + + + Pixel shader sampler. + + D3D10_DST_PS_SAMPLERS + + + + Pixel shader resource. + + D3D10_DST_PS_SHADER_RESOURCES + + + + Pixel shader constant buffer. + + D3D10_DST_PS_CONSTANT_BUFFERS + + + + Input-assembler vertex buffer. + + D3D10_DST_IA_VERTEX_BUFFERS + + + + Input-assembler index buffer. + + D3D10_DST_IA_INDEX_BUFFER + + + + Input-assembler input layout. + + D3D10_DST_IA_INPUT_LAYOUT + + + + Input-assembler primitive topology. + + D3D10_DST_IA_PRIMITIVE_TOPOLOGY + + + + Viewport. + + D3D10_DST_RS_VIEWPORTS + + + + Scissor rectangle. + + D3D10_DST_RS_SCISSOR_RECTS + + + + Rasterizer state. + + D3D10_DST_RS_RASTERIZER_STATE + + + + Predication state. + + D3D10_DST_PREDICATION + + + + No documentation. + + D3D10_EFFECT_VARIABLE_FLAGS + + + + No documentation. + + POOLED + + + + No documentation. + + ANNOTATION + + + + No documentation. + + EXPLICIT_BIND_POINT + + + + None. + + None + + + + The version of hardware acceleration requested. + + + Use this enumeration when creating a device with or . Note that 10level9 feature levels 9_1, 9_2, and 9_3 are only available with the DirectX 11 Runtime (Windows 7, Windows Server 2008 R2, updated Windows Vista [KB971644]). For information about limitations creating nonhardware-type devices on certain feature levels, see {{Limitations Creating WARP and Reference Devices}}. The following table lists the features available per feature level: 10_110_09_39_29_1 Shader Model4.x4.02.0 (4_0_level_9_3)2.0 (4_0_level_9_1)2.0 (4_0_level_9_1) Geometry ShaderYesYesNoNoNo Stream OutYesYesNoNoNo Texture Resource ArraysYesYesNoNoNo Cubemap Resource ArraysYesNoNoNoNo BC4/BC5 CompressionYesYesNoNoNo Alpha-to-coverageYesYesNoNoNo Extended Formats*(BGRA, etc.)OptionalOptionalYesYesYes 10-bit XR High Color FormatOptionalOptionalN/AN/AN/A Max Texture Dimension81928192409620482048 Max Cubemap Dimension819281924096512512 Max Volume Extent20482048256256256 Max Texture Repeat8192819281922048128 Max Anisotropy161616162 Max Primitive Count2^322^321048575104857565535 Simultaneous Render Targets88411 Occlusion QueriesYesYesYesYesNo Separate Alpha BlendYesYesYesYesNo Mirror OnceYesYesYesYesNo Overlapping Vertex ElementsYesYesYesYesNo Independent Write MasksYesYesYesNoNo InstancingYesYesYesNoNo Nonpowers-of-2 conditionally*NoNoYesYesYes Nonpowers-of-2 unconditionally**YesYesNoNoNo ? * At feature levels 9_1, 9_2 and 9_3, the display device supports the use of 2-D textures with dimensions that are not powers of two under two conditions. First, only one MIP-map level for each texture can be created, and second, no wrap sampler modes for textures are allowed (that is, the AddressU, AddressV, and AddressW members of cannot be set to ). ** At feature levels 10_0 and 10_1, the display device unconditionally supports the use of 2-D textures with dimensions that are not powers of two. + + D3D10_FEATURE_LEVEL1 + + + + The hardware supports Direct3D 10.0 features. + + D3D10_FEATURE_LEVEL_10_0 + + + + The hardware supports Direct3D 10.1 features. + + D3D10_FEATURE_LEVEL_10_1 + + + + The hardware supports Direct3D 9.1 features. + + D3D10_FEATURE_LEVEL_9_1 + + + + The hardware supports Direct3D 9.2 features. + + D3D10_FEATURE_LEVEL_9_2 + + + + The hardware supports Direct3D 9.3 features. + + D3D10_FEATURE_LEVEL_9_3 + + + + No documentation. + + D3D10_STANDARD_MULTISAMPLE_QUALITY_LEVELS + + + + No documentation. + + D3D10_STANDARD_MULTISAMPLE_PATTERN + + + + No documentation. + + D3D10_CENTER_MULTISAMPLE_PATTERN + + + + Sprite flags that tell the sprite drawing API how to behave. These are passed into . + + + After a front-to-back or back-to-front sort is done, it will automatically do a secondary sort by texture. This is helpful for when there are many sprites with the same texture all on the same plane, such as when drawing the user interface in a game. + + D3DX10_SPRITE_FLAG + + + + Sort the sprites by texture before rendering so that when there are many sprites with the same texture that texture all of those sprites will be rendered at the same time, thereby improving performance. + + D3DX10_SPRITE_SORT_TEXTURE + + + + Sort the sprites from back to front to that those farther away from the camera will be drawn first. + + D3DX10_SPRITE_SORT_DEPTH_BACK_TO_FRONT + + + + Sort the sprites from front to back so that those closer to the camera will be drawn first. + + D3DX10_SPRITE_SORT_DEPTH_FRONT_TO_BACK + + + + Saves the state so that when is called, it will restore the state to the way it was before was called. + + D3DX10_SPRITE_SAVE_STATE + + + + Calls AddRef on all of the textures when they are passed into . + + D3DX10_SPRITE_ADDREF_TEXTURES + + + + None. + + None + + + + Texture filtering flags. + + + D3DX10 automatically performs gamma correction (to convert color data from RGB space to standard RGB space) when loading texture data. This is automatically done for instance when RGB data is loaded from a .png file into an sRGB texture. Use the SRGB filter flags to indicate if the data does not need to be converted into sRGB space. + + D3DX10_FILTER_FLAG + + + + No scaling or filtering will take place. Pixels outside the bounds of the source image are assumed to be transparent black. + + D3DX10_FILTER_NONE + + + + Each destination pixel is computed by sampling the nearest pixel from the source image. + + D3DX10_FILTER_POINT + + + + Each destination pixel is computed by sampling the four nearest pixels from the source image. This filter works best when the scale on both axes is less than two. + + D3DX10_FILTER_LINEAR + + + + Every pixel in the source image contributes equally to the destination image. This is the slowest of the filters. + + D3DX10_FILTER_TRIANGLE + + + + Each pixel is computed by averaging a 2x2(x2) box of pixels from the source image. This filter works only when the dimensions of the destination are half those of the source, as is the case with mipmaps. + + D3DX10_FILTER_BOX + + + + Pixels off the edge of the texture on the u-axis should be mirrored, not wrapped. + + D3DX10_FILTER_MIRROR_U + + + + Pixels off the edge of the texture on the v-axis should be mirrored, not wrapped. + + D3DX10_FILTER_MIRROR_V + + + + Pixels off the edge of the texture on the w-axis should be mirrored, not wrapped. + + D3DX10_FILTER_MIRROR_W + + + + Specifying this flag is the same as specifying the D3DX_FILTER_MIRROR_U, D3DX_FILTER_MIRROR_V, and D3DX_FILTER_MIRROR_W flags. + + D3DX10_FILTER_MIRROR + + + + The resulting image must be dithered using a 4x4 ordered dither algorithm. This happens when converting from one format to another. + + D3DX10_FILTER_DITHER + + + + Do diffuse dithering on the image when changing from one format to another. + + D3DX10_FILTER_DITHER_DIFFUSION + + + + Input data is in standard RGB (sRGB) color space. See remarks. + + D3DX10_FILTER_SRGB_IN + + + + Output data is in standard RGB (sRGB) color space. See remarks. + + D3DX10_FILTER_SRGB_OUT + + + + Same as specifying D3DX_FILTER_SRGB_IN | D3DX_FILTER_SRGB_OUT. See remarks. + + D3DX10_FILTER_SRGB + + + + These flags are used to control how generates normal maps. Any number of these flags may be OR'd together in any combination. + + D3DX10_NORMALMAP_FLAG + + + + Indicates that pixels off the edge of the texture on the U-axis should be mirrored, not wraped. + + D3DX10_NORMALMAP_MIRROR_U + + + + Indicates that pixels off the edge of the texture on the V-axis should be mirrored, not wraped. + + D3DX10_NORMALMAP_MIRROR_V + + + + Same as D3DX10_NORMALMAP_MIRROR_U | D3DX10_NORMALMAP_MIRROR_V. + + D3DX10_NORMALMAP_MIRROR + + + + Inverts the direction of each normal. + + D3DX10_NORMALMAP_INVERTSIGN + + + + Computes the per pixel occlusion term and encodes it into the alpha. An Alpha of 1 means that the pixel is not obscured in any way, and an alpha of 0 would mean that the pixel is completly obscured. + + D3DX10_NORMALMAP_COMPUTE_OCCLUSION + + + + These flags are used by functions which operate on one or more channels in a texture. + + D3DX10_CHANNEL_FLAG + + + + Indicates the red channel should be used. + + D3DX10_CHANNEL_RED + + + + Indicates the blue channel should be used. + + D3DX10_CHANNEL_BLUE + + + + Indicates the green channel should be used. + + D3DX10_CHANNEL_GREEN + + + + Indicates the alpha channel should be used. + + D3DX10_CHANNEL_ALPHA + + + + Indicates the luminaces of the red, green, and blue channels should be used. + + D3DX10_CHANNEL_LUMINANCE + + + + None. + + None + + + + Image file formats supported by D3DXCreatexxx and D3DX10Savexxx functions. + + + See {{Types of Bitmaps (GDI+)}} for more information on some of these formats. D3DX10 makes use of the Windows Imaging Component to implement the majority of the supported bitmap file types. See {{Windows Imaging Component Overview}} for additional information. + + + D3DX10_IMAGE_FILE_FORMAT + + + + Windows bitmap (BMP) file format. Contains a header that describes the resolution of the device on which the rectangle of pixels was created, the dimensions of the rectangle, the size of the array of bits, a logical palette, and an array of bits that defines the relationship between pixels in the bitmapped image and entries in the logical palette. + + D3DX10_IFF_BMP + + + + Joint Photographic Experts Group (JPEG) compressed file format. Specifies variable compression of 24-bit RGB color and 8-bit gray-scale Tagged Image File Format (TIFF) image document files. + + D3DX10_IFF_JPG + + + + Portable Network Graphics (PNG) file format. A non-proprietary bitmap format using lossless compression. + + D3DX10_IFF_PNG + + + + DirectDraw surface (DDS) file format. Stores textures, volume textures, and cubic environment maps, with or without mipmap levels, and with or without pixel compression. + + D3DX10_IFF_DDS + + + + Tagged Image File Format (TIFF). + + D3DX10_IFF_TIFF + + + + Graphics Interchange Format (GIF). + + D3DX10_IFF_GIF + + + + Windows Media Player format (WMP). + + D3DX10_IFF_WMP + + + + No documentation. + + _D3DX10_MESH + + + + No documentation. + + D3DX10_MESH_32_BIT + + + + No documentation. + + D3DX10_MESH_GS_ADJACENCY + + + + None. + + None + + + + Specifies which pieces of mesh data to discard from the device. Used with . + + D3DX10_MESH_DISCARD_FLAGS + + + + Discard the attribute buffer. + + D3DX10_MESH_DISCARD_ATTRIBUTE_BUFFER + + + + Discard the attribute table. + + D3DX10_MESH_DISCARD_ATTRIBUTE_TABLE + + + + Discard the reference reps buffer. + + D3DX10_MESH_DISCARD_POINTREPS + + + + Discard the adjacency buffer. + + D3DX10_MESH_DISCARD_ADJACENCY + + + + Discard the buffers committed to the device (with ). + + D3DX10_MESH_DISCARD_DEVICE_BUFFERS + + + + No documentation. + + _D3DX10_MESHOPT + + + + No documentation. + + D3DX10_MESHOPT_COMPACT + + + + No documentation. + + D3DX10_MESHOPT_ATTR_SORT + + + + No documentation. + + D3DX10_MESHOPT_VERTEX_CACHE + + + + No documentation. + + D3DX10_MESHOPT_STRIP_REORDER + + + + No documentation. + + D3DX10_MESHOPT_IGNORE_VERTS + + + + No documentation. + + D3DX10_MESHOPT_DO_NOT_SPLIT + + + + No documentation. + + D3DX10_MESHOPT_DEVICE_INDEPENDENT + + + + D3D10 Functions. + + + + Constant None. + + + Constant None. + + + + Load DLLs and bind functions + + + + + Create a Direct3D 10.0 device that represents the display adapter. + + + This example creates a reference device. + ID3D10Device* g_pd3dDevice = NULL; + D3D10CreateDevice( NULL, D3D10_DRIVER_TYPE_REFERENCE, NULL, 0, D3D10_SDK_VERSION, &g_pd3dDevice ); + + To create a device and a swap chain at the same time, see . The object returned by D3D10CreateDevice implements the interface and can be queried for other interfaces the object supports. To retrieve the interface of the object the following code could be used. + IDXGIDevice * pDXGIDevice; + hr = g_pd3dDevice->QueryInterface(__uuidof(IDXGIDevice), (void **)&pDXGIDevice); + + + + Pointer to the display adapter (see ) when creating a hardware device; otherwise set this parameter to NULL. If NULL is specified when creating a hardware device, Direct3D will use the first adapter enumerated by {{EnumAdapters}}. + The device-driver type (see ). The driver type determines the type of device you will create. + Reserved. Set to NULL. + Optional. Device creation flags (see ) that enable {{API layers}}. These flags can be bitwise OR'd together. + Bit flag that indicates the version of the SDK. Should always be D3D10_SDK_VERSION. + Address of a reference to the device created (see ). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3D10CreateDevice([None] IDXGIAdapter* pAdapter,[None] D3D10_DRIVER_TYPE DriverType,[None] void* Software,[None] D3D10_CREATE_DEVICE_FLAG Flags,[None] int SDKVersion,[Out] ID3D10Device** ppDevice) + + + + Create a Direct3D 10.0 device and a swap chain. + + + To create a device without creating a swap chain, see . + + Pointer to a . + The type of driver for the device. See . + A handle to the DLL that implements a software rasterizer. Must be NULL if DriverType is non-software. The HMODULE of a DLL can be obtained with {{LoadLibrary}}, {{LoadLibraryEx}}, or {{GetModuleHandle}}. + Optional. Device creation flags (see ) that enable {{API layers}}. These flags can be bitwise OR'd together. + Bit flag that indicates the version of the SDK. Should be D3D10_SDK_VERSION, defined in d3d10.h. + Description of the swap chain. See . + Address of a reference to an . + Address of a reference to an that will receive the newly created device. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3D10CreateDeviceAndSwapChain([None] IDXGIAdapter* pAdapter,[None] D3D10_DRIVER_TYPE DriverType,[None] void* Software,[None] D3D10_CREATE_DEVICE_FLAG Flags,[None] int SDKVersion,[In] DXGI_SWAP_CHAIN_DESC* pSwapChainDesc,[Out] IDXGISwapChain** ppSwapChain,[Out] ID3D10Device** ppDevice) + + + + Combine two state-block masks with a bitwise OR. + + State block mask on the left side of the bitwise OR operation. See . + State block mask on the right side of the bitwise OR operation. + The result of the bitwise OR operation. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3D10StateBlockMaskUnion([None] D3D10_STATE_BLOCK_MASK* pA,[None] D3D10_STATE_BLOCK_MASK* pB,[None] D3D10_STATE_BLOCK_MASK* pResult) + + + + Combine two state-block masks with a bitwise AND. + + State block mask on the left side of the bitwise AND operation. See . + State block mask on the right side of the bitwise AND operation. + The result of the bitwise AND operation. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3D10StateBlockMaskIntersect([None] D3D10_STATE_BLOCK_MASK* pA,[None] D3D10_STATE_BLOCK_MASK* pB,[None] D3D10_STATE_BLOCK_MASK* pResult) + + + + Combine two state-block masks with a bitwise XOR. + + State block mask on the left side of the bitwise XOR operation. See . + State block mask on the right side of the bitwise XOR operation. + The result of the bitwise XOR operation. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3D10StateBlockMaskDifference([None] D3D10_STATE_BLOCK_MASK* pA,[None] D3D10_STATE_BLOCK_MASK* pB,[None] D3D10_STATE_BLOCK_MASK* pResult) + + + + Enable a range of state values in a state block mask. + + + This is an example of how to call this function. It create a mask that can capture and apply to geometry-shader samplers in slots 2 ~ 13. + D3D10_STATE_BLOCK_MASK stateBlockMask; + D3D10StateBlockMaskEnableCapture(&stateBlockMask, D3D10_DST_GS_SAMPLERS, 2, 13); + + + + A state block mask (see ). + The type of device state to enable (see . + The lower end of the range of values to set to true. + The upper end of the range of values to set to true. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3D10StateBlockMaskEnableCapture([None] D3D10_STATE_BLOCK_MASK* pMask,[None] D3D10_DEVICE_STATE_TYPES StateType,[None] int RangeStart,[None] int RangeLength) + + + + Disable state capturing with a state-block mask. + + + This is an example of how to call this function. It creates a mask that cannot capture and apply to geometry-shader samplers in slots 2 ~ 23. + D3D10_STATE_BLOCK_MASK stateBlockMask; + D3D10StateBlockMaskDisableCapture(&stateBlockMask, D3D10_DST_GS_SAMPLERS, 2, 23); + + + + A state block mask (see ). + The type of device state to disable (see ). + The lower end of the range of values to set to false. + The upper end of the range of values to set to false. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3D10StateBlockMaskDisableCapture([None] D3D10_STATE_BLOCK_MASK* pMask,[None] D3D10_DEVICE_STATE_TYPES StateType,[None] int RangeStart,[None] int RangeLength) + + + + Enable a state-block mask to capture and apply all state variables. + + A mask with everything turned on. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3D10StateBlockMaskEnableAll([None] D3D10_STATE_BLOCK_MASK* pMask) + + + + Disable all state capturing with a state-block mask. + + A mask filled with all zeroes (see ). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3D10StateBlockMaskDisableAll([None] D3D10_STATE_BLOCK_MASK* pMask) + + + + Get an element in a state-block mask; determine if an element is allowed by the mask for capturing and applying. + + State block mask. See . + The type of device state. See . + The entry within the device state. This is only relevant for state types that have more than one entry, such as D3D10_DST_GS_SAMPLERS. + Returns true if the specified feature is allowed by the mask for capturing and applying, and false otherwise. + BOOL D3D10StateBlockMaskGetSetting([None] D3D10_STATE_BLOCK_MASK* pMask,[None] D3D10_DEVICE_STATE_TYPES StateType,[None] int Entry) + + + + Create a state block. + + + A state block is a collection of device state, and is used for saving and restoring device state. Use a state-block mask to enable subsets of state for saving and restoring. The structure can be filled manually or by using any of the D3D10StateBlockMaskXXX APIs. A state block mask can also be obtained by calling or . Differences between Direct3D 9 and Direct3D 10: In Direct3D 10, a state block object does not contain any valid information about the state of the device until is called. In Direct3D 9, state is saved in a state block object, when it is created. ? + + The device for which the state block will be created. + Indicates which parts of the device state will be captured when calling and reapplied when calling . See remarks. + Address of a reference to the buffer created (see ). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3D10CreateStateBlock([None] ID3D10Device* pDevice,[None] D3D10_STATE_BLOCK_MASK* pStateBlockMask,[None] ID3D10StateBlock** ppStateBlock) + + + + Creates an ID3D10Effect from a buffer containing a compiled effect. + + + This method is used to create an object from an effect that has been compiled before runtime and loaded into memory. For help precompiling an effect, see {{Offline Compiling}}. To load and compile an ASCII .fx file see {{Compile an Effect (Direct3D 10)}}. + + A reference to a compiled effect. + Length of pData. + Effect {{compile options}}. + A reference to the device (see ). + Optional. A reference to an memory space for effect variables that are shared across effects (see ). + A reference to an which contains the created effect. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3D10CreateEffectFromMemory([None] void* pData,[None] SIZE_T DataLength,[None] int FXFlags,[None] ID3D10Device* pDevice,[None] ID3D10EffectPool* pEffectPool,[Out] ID3D10Effect** ppEffect) + + + + Create an effect pool (or shared memory location), to enable sharing variables between effects. + + + A pool is a shared location in memory. Effect variables that are located in a pool can be updated once, and the effect system will take care of updating each effect that uses that variable. To pool an effect variable, tell the effect to locate the variable in a pool when the effect is created, using a helper function such as {{D3DX10CreateEffectFromFile}}. For help compiling an effect, see {{Compile an Effect (Direct3D 10)}}. + + A reference to a compiled effect. + Length of pData. + Effect {{compile options}}. + A reference to the device (see ). + A reference to the that contains the effect pool. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3D10CreateEffectPoolFromMemory([None] void* pData,[None] SIZE_T DataLength,[None] int FXFlags,[None] ID3D10Device* pDevice,[None] ID3D10EffectPool** ppEffectPool) + + + + Create a Direct3D 10.1 device that represents the display adapter. + + + To create a device and a swap chain at the same time, see . This method requires Windows Vista Service Pack 1, Windows Server 2008, or later release of Windows. The object returned by D3D10CreateDevice1 implements the interface and can be queried for other interfaces the object supports. To retrieve the interface of the object the following code could be used. + IDXGIDevice * pDXGIDevice; + hr = g_pd3dDevice->QueryInterface(__uuidof(IDXGIDevice), (void **)&pDXGIDevice); + + + + Pointer to the display adapter (see ) when creating a hardware device; otherwise set this parameter to NULL. If NULL is specified when creating a hardware device, Direct3D will use the first adapter enumerated by {{EnumAdapters}}. + The device-driver type (see ). The driver type determines the type of device you will create. + This is set to NULL except for D3D10_DRIVER_TYPE_SOFTWARE driver types. + Optional. Device creation flags (see ) that enable {{API layers}}. These flags can be bitwise OR'd together. + The version of hardware that is available for acceleration (see ). + Bit flag that indicates the version of the SDK. Should be D3D10_1_SDK_VERSION, defined in D3D10.h. + Address of a reference to the device created (see ). + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3D10CreateDevice1([None] IDXGIAdapter* pAdapter,[None] D3D10_DRIVER_TYPE DriverType,[None] void* Software,[None] D3D10_CREATE_DEVICE_FLAG Flags,[None] D3D10_FEATURE_LEVEL1 HardwareLevel,[None] int SDKVersion,[Out] ID3D10Device1** ppDevice) + + + + Create a Direct3D 10.1 device and a swap chain. + + + To create a device without creating a swap chain, see . This method requires Windows Vista Service Pack 1, Windows Server 2008, or later release of Windows. + + Pointer to a . + The type of driver for the device. See . + A handle to the DLL that implements a software rasterizer. Must be NULL if DriverType is non-software. The HMODULE of a DLL can be obtained with {{LoadLibrary}}, {{LoadLibraryEx}}, or {{GetModuleHandle}}. + Optional. Device creation flags (see ) that enable {{API layers}}. These flags can be bitwise OR'd together. + The version of hardware that is available for acceleration (see ). + Bit flag that indicates the version of the SDK. Should be D3D10_1_SDK_VERSION, defined in D3D10.h. + Description of the swap chain. See . + Address of a reference to an . + Address of a reference to an that will receive the newly created device. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3D10CreateDeviceAndSwapChain1([None] IDXGIAdapter* pAdapter,[None] D3D10_DRIVER_TYPE DriverType,[None] void* Software,[None] D3D10_CREATE_DEVICE_FLAG Flags,[None] D3D10_FEATURE_LEVEL1 HardwareLevel,[None] int SDKVersion,[None] DXGI_SWAP_CHAIN_DESC* pSwapChainDesc,[Out] IDXGISwapChain** ppSwapChain,[Out] ID3D10Device1** ppDevice) + + + + D3DX10 Functions. + + + + + Load DLLs and bind functions + + + + + Create the best Direct3D 10 device that represents the display adapter. If a Direct3D 10.1-compatible device can be created, it will be possible to acquire an reference from the returned device interface reference. + + + This function attempts to create the best device for the hardware. First, the function attempts to create a 10.1 device. If a 10.1 device cannot be created, the function attempts to create a 10.0 device. If neither device is successfully created, the function returns E_FAIL. If your application needs to create only a 10.1 device, or a 10.0 device only, use the following functions instead: Use the function to create a Direct3D 10.0 device only. Use the function to create a Direct3D 10.1 device only. Use the function to get an interface reference from an interface reference. A Direct3D 10.1 device can only be created on computers running Windows Vista Service Pack 1 or later, and with Direct3D 10.1-compatible hardware installed. However, it is legal to call this function on computers running any version of Windows that has the D3DX10 DLL installed. + + Pointer to the display adapter (see the interface) when creating a hardware device; otherwise set this parameter to NULL. If NULL is specified when creating a hardware device, Direct3D will use the first adapter enumerated by the interface. + The device-driver type (see the enumeration). The driver type determines the type of device you will create. + A handle to a loaded module that implements a software driver (such as D3D10Ref.dll). To get a handle, call the {{GetModuleHandle}} function. + Device creation flags (see the enumeration) that enable {{API layers}}. These flags can be bitwise OR'd together. + Address of a reference to the device created (see the interface). + This function returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DX10CreateDevice([None] IDXGIAdapter* pAdapter,[None] D3D10_DRIVER_TYPE DriverType,[None] void* Software,[None] int Flags,[None] ID3D10Device** ppDevice) + + + + Create the best Direct3D device and a swap chain. + + + To create the best device, this method implements more than one device creation option. First, the method attempts to create a 10.1 device (and swap chain). If that fails, the method attempts to create a 10.0 device. If that fails, the method will fail. If your application needs to create only a 10.1 device, or a 10.0 device only, use these APIs instead: Use to create a Direct3D 10.0 (only) device and swap chain. Use to create a Direct3D 10.1 (only) device and swap chain. This method requires Windows Vista Service Pack 1. + + Pointer to a . + The type of driver for the device. See . + A handle to the DLL that implements a software rasterizer. Must be NULL if DriverType is non-software. The HMODULE of a DLL can be obtained with {{LoadLibrary}}, {{LoadLibraryEx}}, or {{GetModuleHandle}}. + Optional. Device creation flags (see ) that enable {{API layers}}. These flags can be bitwise OR'd together. + Description of the swap chain. See . + Address of a reference to an . + Address of a reference to an that will receive the newly created device. + This method returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DX10CreateDeviceAndSwapChain([None] IDXGIAdapter* pAdapter,[None] D3D10_DRIVER_TYPE DriverType,[None] void* Software,[None] int Flags,[None] DXGI_SWAP_CHAIN_DESC* pSwapChainDesc,[None] IDXGISwapChain** ppSwapChain,[None] ID3D10Device** ppDevice) + + + + Get a Direct3D 10.1 device interface reference from a Direct3D 10.0 interface reference. + + + For this function to succeed, you must have acquired the supplied reference using a call to the function, the function, the function, or the function. You can only create a Direct3D 10.1 device on computers running Windows Vista Service Pack 1 or later, and with Direct3D 10.1-compatible hardware installed. This function will return E_FAIL on any computer not meeting these requirements. + However, you can call this function on any version of Windows that has the D3DX10 DLL installed. + + Pointer to the Direct3D 10.0 device (see the interface). + Pointer to the Direct3D 10.1 device (see the interface). + This function returns one of the following {{Direct3D 10 Return Codes}}. If a Direct3D 10.1 device interface can be acquired, this function succeeds and passes a reference to the 10.1 interface using the ppDevice parameter. If a Direct3D 10.1 device interface cannot be acquired, this function returns E_FAIL, and will not return anything for the ppDevice parameter. + HRESULT D3DX10GetFeatureLevel1([None] ID3D10Device* pDevice,[None] ID3D10Device1** ppDevice1) + + + + Verify that the version of D3DX you compiled with is the version that you are running. + + + Use this function during the initialization of your application. + HRESULT hr; if( FAILED( D3DX10CheckVersion(D3D10_SDK_VERSION, D3DX10_SDK_VERSION) ) ) return E_FAIL; + + + + Use D3D10_SDK_VERSION. See remarks. + Use D3DX10_SDK_VERSION. See remarks. + If the version doesn't match, the function will return FALSE (a number less than or equal to 0, the number itself has no meaning). + HRESULT D3DX10CheckVersion([None] int D3DSdkVersion,[None] int D3DX10SdkVersion) + + + + Create a sprite for drawing a 2D texture. + + A reference to the device (see ) that will draw the sprite. + The size of the vertex buffer, in number of sprites, that will be sent to the device when or is called. This should be a small number if you know you will be rendering a small number of sprites at a time (to save memory) and a large number if you know you will be rendering a large number of sprites at a time. The maximum value is 4096. If 0 is specified, the vertex buffer size will automatically be set to 4096. + The address of a reference to a sprite interface (see ). + If the function succeeds, the return value is S_OK. If the function fails, the return value can be one of the following: D3DERR_INVALIDCALL, E_OUTOFMEMORY. + HRESULT D3DX10CreateSprite([None] ID3D10Device* pDevice,[None] int cDeviceBufferSize,[None] LPD3DX10SPRITE* ppSprite) + + + + Creates a font object for a device and font. + + + The compiler setting also determines the function version. If Unicode is defined, the function call resolves to D3DXCreateFontW. Otherwise, the function call resolves to D3DXCreateFontA because ANSI strings are being used. If you want more information about font parameters, see {{The Logical Font}}. + + Pointer to an ID3D10Device interface, the device to be associated with the font object. + The height of the characters in logical units. + The width of the characters in logical units. + Typeface weight. One example is bold. + The number of mipmap levels. + True for italic font, false otherwise. + The character set of the font. + Specifies how Windows should attempt to match the desired font sizes and characteristics with actual fonts. Use OUT_TT_ONLY_PRECIS for instance, to ensure that you always get a TrueType font. + Specifies how Windows should match the desired font with a real font. It applies to raster fonts only and should not affect TrueType fonts. + Pitch and family index. + String containing the typeface name. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. See Remarks. + Returns a reference to an ID3DX10Font interface, representing the created font object. + If the function succeeds, the return value is S_OK. If the function fails, the return value can be one of the following: D3DERR_INVALIDCALL, D3DXERR_INVALIDDATA, E_OUTOFMEMORY. + HRESULT D3DX10CreateFontW([None] ID3D10Device* pDevice,[None] int Height,[None] int Width,[None] int Weight,[None] int MipLevels,[None] BOOL Italic,[None] int CharSet,[None] int OutputPrecision,[None] int Quality,[None] int PitchAndFamily,[None] const wchar_t* pFaceName,[None] LPD3DX10FONT* ppFont) + + + + Creates a font object. + + Pointer to an interface. + Pointer to a {{D3DX10_FONT_DESC}} structure, describing the attributes of the font object to create. If Unicode is defined, the function call resolves to D3DXCreateFontIndirectW. Otherwise, the function call resolves to D3DXCreateFontIndirectA because ANSI strings are being used. + Returns a reference to an . + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10CreateFontIndirectW([None] ID3D10Device* pDevice,[None] const D3DX10_FONT_DESCW* pDesc,[None] LPD3DX10FONT* ppFont) + + + + Retrieves information about a given image file. + + + This function supports both Unicode and ANSI strings. + + File name of image to retrieve information about. If UNICODE or _UNICODE are defined, this parameter type is LPCWSTR, otherwise, the type is LPCSTR. + Optional thread pump that can be used to load the info asynchronously. Can be NULL. See . + Pointer to a D3DX10_IMAGE_INFO structure to be filled with the description of the data in the source file. + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + If the function succeeds, the return value is D3D_OK. If the function fails, the return value can be the following: D3DERR_INVALIDCALL + HRESULT D3DX10GetImageInfoFromFileW([None] const wchar_t* pSrcFile,[None] ID3DX10ThreadPump* pPump,[None] D3DX10_IMAGE_INFO* pSrcInfo,[None] HRESULT* pHResult) + + + + Retrieves information about a given image in a resource. + + + The compiler setting also determines the function version. If Unicode is defined, the function call resolves to D3DX10GetImageInfoFromResourceW. Otherwise, the function call resolves to D3DX10GetImageInfoFromResourceA because ANSI strings are being used. + + Module where the resource is loaded. Set this parameter to NULL to specify the module associated with the image that the operating system used to create the current process. + Pointer to a string that specifies the filename. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. See Remarks. + Optional thread pump that can be used to load the info asynchronously. Can be NULL. See . + Pointer to a D3DX10_IMAGE_INFO structure to be filled with the description of the data in the source file. + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + If the function succeeds, the return value is D3D_OK. If the function fails, the return value can be the following: D3DERR_INVALIDCALL + HRESULT D3DX10GetImageInfoFromResourceW([None] void* hSrcModule,[None] const wchar_t* pSrcResource,[None] ID3DX10ThreadPump* pPump,[None] D3DX10_IMAGE_INFO* pSrcInfo,[None] HRESULT* pHResult) + + + + Get information about an image already loaded into memory. + + Pointer to the image in memory. + Size of the image in memory, in bytes. + Optional thread pump that can be used to load the info asynchronously. Can be NULL. See . + Information about the image in memory. + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10GetImageInfoFromMemory([None] const void* pSrcData,[None] SIZE_T SrcDataSize,[None] ID3DX10ThreadPump* pPump,[None] D3DX10_IMAGE_INFO* pSrcInfo,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a file. + + A reference to the device (see ) that will use the resource. + Name of the file that contains the shader-resource view. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. + Optional. Identifies the characteristics of a texture (see ) when the data processor is created; set this to NULL to read the characteristics of a texture when the texture is loaded. + Pointer to a thread-pump interface (see ). If NULL is specified, this function will behave synchronously and will not return until it is finished. + Address of a reference to the shader-resource view (see ). + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10CreateShaderResourceViewFromFileW([None] ID3D10Device* pDevice,[None] const wchar_t* pSrcFile,[In, Optional] D3DX10_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX10ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a texture resource from a file. + + + For a list of supported image formats see . + + A reference to the device (see ) that will use the resource. + The name of the file containing the resource. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. + Optional. Identifies the characteristics of a texture (see ) when the data processor is created; set this to NULL to read the characteristics of a texture when the texture is loaded. + A reference to a thread pump interface (see ). If NULL is specified, this function will behave synchronously and will not return until it is finished. + The address of a reference to the texture resource (see ). + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10CreateTextureFromFileW([None] ID3D10Device* pDevice,[None] const wchar_t* pSrcFile,[In, Optional] D3DX10_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX10ThreadPump* pPump,[Out] ID3D10Resource** ppTexture,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a resource. + + A reference to the device (see ) that will use the resource. + Handle to the resource module containing the shader-resource view. HMODULE can be obtained with {{GetModuleHandle Function}}. + Name of the shader resource view in hSrcModule. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. + Optional. Identifies the characteristics of a texture (see ) when the data processor is created; set this to NULL to read the characteristics of a texture when the texture is loaded. + A reference to a thread pump interface (see ). If NULL is specified, this function will behave synchronously and will not return until it is finished. + Address of a reference to the shader-resource view (see ). + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10CreateShaderResourceViewFromResourceW([None] ID3D10Device* pDevice,[None] void* hSrcModule,[None] const wchar_t* pSrcResource,[In, Optional] D3DX10_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX10ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a texture from another resource. + + + For a list of supported image formats see . + + A reference to the device (see ) that will use the resource. + A handle to the source resource. HMODULE can be obtained with {{GetModuleHandle Function}}. + A string that contains the name of the source resource. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. + Optional. Identifies the characteristics of a texture (see ) when the data processor is created; set this to NULL to read the characteristics of a texture when the texture is loaded. + A reference to a thread pump interface (see ). If NULL is specified, this function will behave synchronously and will not return until it is finished. + The address of a reference to the texture resource (see ). + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10CreateTextureFromResourceW([None] ID3D10Device* pDevice,[None] void* hSrcModule,[None] const wchar_t* pSrcResource,[In, Optional] D3DX10_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX10ThreadPump* pPump,[Out] ID3D10Resource** ppTexture,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a file in memory. + + A reference to the device (see ) that will use the resource. + Pointer to the file in memory that contains the shader-resource view. + Size of the file in memory. + Optional. Identifies the characteristics of a texture (see ) when the data processor is created; set this to NULL to read the characteristics of a texture when the texture is loaded. + A reference to a thread pump interface (see ). If NULL is specified, this function will behave synchronously and will not return until it is finished. + Address of a reference to the newly created shader resource view. See . + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10CreateShaderResourceViewFromMemory([None] ID3D10Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX10_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX10ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a texture resource from a file residing in system memory. + + + For a list of supported image formats see . + + A reference to the device (see ) that will use the resource. + Pointer to the resource in system memory. + Size of the resource in system memory. + Optional. Identifies the characteristics of a texture (see ) when the data processor is created; set this to NULL to read the characteristics of a texture when the texture is loaded. + A reference to a thread pump interface (see ). If NULL is specified, this function will behave synchronously and will not return until it is finished. + Address of a reference to the created resource. See . + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10CreateTextureFromMemory([None] ID3D10Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX10_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX10ThreadPump* pPump,[Out] ID3D10Resource** ppTexture,[None] HRESULT* pHResult) + + + + Load a texture from a texture. + + Pointer to the source texture. See . + Pointer to texture loading parameters. See . + Pointer to the destination texture. See . + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10LoadTextureFromTexture([None] ID3D10Resource* pSrcTexture,[None] D3DX10_TEXTURE_LOAD_INFO* pLoadInfo,[None] ID3D10Resource* pDstTexture) + + + + Generates mipmap chain using a particular texture filter. + + The texture object to be filtered. See . + The mipmap level whose data is used to generate the rest of the mipmap chain. + Flags controlling how each miplevel is filtered (or D3DX10_DEFAULT for D3DX10_FILTER_BOX). See . + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10FilterTexture([None] ID3D10Resource* pTexture,[None] int SrcLevel,[None] int MipFilter) + + + + Save a texture to a file. + + Pointer to the texture to be saved. See . + The format the texture will be saved as (see ). D3DX10_IFF_DDS is the preferred format since it is the only option that supports all the formats in . + Name of the destination output file where the texture will be saved. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}; use the return value to see if the DestFormat is supported. + HRESULT D3DX10SaveTextureToFileW([None] ID3D10Resource* pSrcTexture,[None] D3DX10_IMAGE_FILE_FORMAT DestFormat,[None] const wchar_t* pDestFile) + + + + Save a texture to memory. + + Pointer to the texture to be saved. See . + The format the texture will be saved as. See . + Address of a reference to the memory containing the saved texture. See . + Optional. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10SaveTextureToMemory([None] ID3D10Resource* pSrcTexture,[None] D3DX10_IMAGE_FILE_FORMAT DestFormat,[Out] LPD3D10BLOB* ppDestBuf,[None] int Flags) + + + + Converts a height map into a normal map. The (x,y,z) components of each normal are mapped to the (r,g,b) channels of the output texture. + + + This method computes the normal by using the central difference with a kernel size of 3x3. RGB channels in the destination contain biased (x,y,z) components of the normal. The central differencing denominator is hardcoded to 2.0. + + Pointer to an ID3D10Texture2D interface, representing the source height-map texture. + One or more D3DX_NORMALMAP flags that control generation of normal maps. + One D3DX_CHANNEL flag specifying the source of height information. + Constant value multiplier that increases (or decreases) the values in the normal map. Higher values usually make bumps more visible, lower values usually make bumps less visible. + Pointer to an ID3D10Texture2D interface, representing the destination texture. + If the function succeeds, the return value is D3D_OK. If the function fails, the return value can be the following value: D3DERR_INVALIDCALL. + HRESULT D3DX10ComputeNormalMap([None] ID3D10Texture2D* pSrcTexture,[None] D3DX10_NORMALMAP_FLAG Flags,[None] D3DX10_CHANNEL_FLAG Channel,[None] float Amplitude,[None] ID3D10Texture2D* pDestTexture) + + + + Projects a function represented in a cube map into spherical harmonics. + + Order of the SH evaluation, generates Order^2 coefs, degree is Order-1. + Cubemap that is going to be projected into spherical harmonics. See . + Output SH vector for red. + Output SH vector for green. + Output SH vector for blue. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10SHProjectCubeMap([In] int Order,[None] ID3D10Texture2D* pCubeMap,[Out, Buffer] float* pROut,[Out, Buffer, Optional] float* pGOut,[Out, Buffer, Optional] float* pBOut) + + + + Creates a mesh object using a declarator. + + Pointer to an , the device object to be associated with the mesh. + Array of elements, describing the vertex format for the returned mesh. This parameter must map directly to a flexible vertex format (FVF). + The number of elements in pDeclaration. + Semantic that identifies which part of the vertex declaration contains position information. + Number of vertices for the mesh. This parameter must be greater than 0. + Number of faces for the mesh. The valid range for this number is greater than 0, and one less than the maximum DWORD (typically 65534), because the last index is reserved. + Combination of one or more flags from the {{D3DX10_MESH}}, specifying options for the mesh. + Address of a reference to an , representing the created mesh object. + If the function succeeds, the return value is D3D_OK. If the function fails, the return value can be one of the following: D3DERR_INVALIDCALL, E_OUTOFMEMORY. + HRESULT D3DX10CreateMesh([None] ID3D10Device* pDevice,[In, Buffer] const D3D10_INPUT_ELEMENT_DESC* pDeclaration,[None] int DeclCount,[None] const char* pPositionSemantic,[None] int VertexCount,[None] int FaceCount,[None] int Options,[None] ID3DX10Mesh** ppMesh) + + + + Creates an empty skin mesh object using a declarator. + + + Use the to populate the empty skin mesh object returned by this method. + + Address of a reference to an , representing the created skin mesh object. + If the function succeeds, the return value is D3D_OK. If the function fails, the return value can be: E_OUTOFMEMORY. + HRESULT D3DX10CreateSkinInfo([None] LPD3DX10SKININFO* ppSkinInfo) + + + + Create an effect from a file. + + Name of the ASCII effect file. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. + A NULL-terminated array of shader macros (see ); set this to NULL to specify no macros. + A reference to an include interface (see ). This parameter can be NULL. + A string that specifies the {{shader profile}}, or shader model. + HLSL compile options (see {{D3D10_SHADER Constants}}). + Effect compile options (see {{Compile and Effect Flags}}). + A reference to the device (see ) that will use the resources. + Pointer to an effect pool (see ) for sharing variables between effects. + A reference to a thread pump interface (see ). Use NULL to specify that this function should not return until it is completed. + Address of a reference to the effect (see ) that is created. + The address of a reference to memory (see ) that contains effect compile errors, if there were any. + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10CreateEffectFromFileW([None] const wchar_t* pFileName,[In, Buffer, Optional] const D3D10_SHADER_MACRO* pDefines,[None] ID3D10Include* pInclude,[None] const char* pProfile,[None] int HLSLFlags,[None] int FXFlags,[None] ID3D10Device* pDevice,[None] ID3D10EffectPool* pEffectPool,[None] ID3DX10ThreadPump* pPump,[None] ID3D10Effect** ppEffect,[None] ID3D10Blob** ppErrors,[None] HRESULT* pHResult) + + + + Create an effect from memory. + + Pointer to the effect in memory. + Size of the effect in memory. + Name of the effect file in memory. + A NULL-terminated array of shader macros (see ); set this to NULL to specify no macros. + A reference to an include interface (see ). This parameter can be NULL. + A string that specifies the {{shader profile}}, or shader model. + HLSL compile options (see {{D3D10_SHADER Constants}}). + Effect compile options (see {{D3D10_EFFECT Constants}}). + A reference to the device (see ) that will use the resources. + Pointer to an effect pool (see ) for sharing variables between effects. + A reference to a thread pump interface (see ). Use NULL to specify that this function should not return until it is completed. + Address of a reference to the effect (see ) that is created. + The address of a reference to memory (see ) that contains effect compile errors, if there were any. + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10CreateEffectFromMemory([None] const void* pData,[None] SIZE_T DataLength,[None] const char* pSrcFileName,[In, Buffer, Optional] const D3D10_SHADER_MACRO* pDefines,[None] ID3D10Include* pInclude,[None] const char* pProfile,[None] int HLSLFlags,[None] int FXFlags,[None] ID3D10Device* pDevice,[None] ID3D10EffectPool* pEffectPool,[None] ID3DX10ThreadPump* pPump,[None] ID3D10Effect** ppEffect,[None] ID3D10Blob** ppErrors,[None] HRESULT* pHResult) + + + + Create an effect from a resource. + + A handle to the resource module containing the effect. HMODULE can be obtained with {{GetModuleHandle Function}}. + Name of the resource in hModule. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. + Optional. Effect file name, which is used for error messages only. Can be NULL. + A NULL-terminated array of shader macros (see ); set this to NULL to specify no macros. + A reference to an include interface (see ). This parameter can be NULL. + A string that specifies the {{shader profile}}, or shader model. + HLSL compile options (see {{D3D10_SHADER Constants}}). + Effect compile options (see {{Compile and Effect Flags}}). + A reference to the device (see ) that will use the resources. + Pointer to an effect pool (see ) for sharing variables between effects. + A reference to a thread pump interface (see ). Use NULL to specify that this function should not return until it is completed. + Address of a reference to the effect (see ) that is created. + The address of a reference to memory (see ) that contains effect compile errors, if there were any. + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10CreateEffectFromResourceW([None] void* hModule,[None] const wchar_t* pResourceName,[None] const wchar_t* pSrcFileName,[In, Buffer, Optional] const D3D10_SHADER_MACRO* pDefines,[None] ID3D10Include* pInclude,[None] const char* pProfile,[None] int HLSLFlags,[None] int FXFlags,[None] ID3D10Device* pDevice,[None] ID3D10EffectPool* pEffectPool,[None] ID3DX10ThreadPump* pPump,[None] ID3D10Effect** ppEffect,[None] ID3D10Blob** ppErrors,[None] HRESULT* pHResult) + + + + Create an effect pool from an effect file. + + + This example creates an effect pool from the effect used in the {{BasicHLSL10 Sample}}. + // Create an effect pool from an effect in memory + ID3D10EffectPool * l_pEffectPool = NULL; + ID3D10Blob* l_pBlob_Errors = NULL; + WCHAR str[MAX_PATH]; + hr = DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"BasicHLSL10.fx" ); + hr = D3DX10CreateEffectPoolFromFile( str, NULL, NULL, D3D10_SHADER_ENABLE_STRICTNESS, 0, pd3dDevice, NULL, &l_pEffectPool, &l_pBlob_Errors ); + + + + The effect filename. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. + A NULL-terminated array of shader macros (see ); set this to NULL to specify no macros. + A reference to an include interface (see ). This parameter can be NULL. + A string that specifies the {{shader profile}}, or shader model. + HLSL compile options (see {{D3D10_SHADER Constants}}). + Effect compile options (see {{Compile and Effect Flags}}). + A reference to the device (see ) that will use the resources. + A reference to a thread pump interface (see ). Use NULL to specify that this function should not return until it is completed. + The address of a reference to the effect pool (see ). + The address of a reference to memory (see ) that contains effect compile errors, if there were any. + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10CreateEffectPoolFromFileW([None] const wchar_t* pFileName,[In, Buffer, Optional] const D3D10_SHADER_MACRO* pDefines,[None] ID3D10Include* pInclude,[None] const char* pProfile,[None] int HLSLFlags,[None] int FXFlags,[None] ID3D10Device* pDevice,[None] ID3DX10ThreadPump* pPump,[None] ID3D10EffectPool** ppEffectPool,[None] ID3D10Blob** ppErrors,[None] HRESULT* pHResult) + + + + Create an effect pool from an effect in memory. + + A reference to the effect. + The size of the effect. + The name of the effect file. + A NULL-terminated array of shader macros (see ); set this to NULL to specify no macros. + A reference to an include interface (see ). This parameter can be NULL. + A string that specifies the {{shader profile}}, or shader model. + HLSL compile options (see {{D3D10_SHADER Constants}}). + Effect compile options (see {{Compile and Effect Flags}}). + A reference to the device (see ) that will use the resources. + A reference to a thread pump interface (see ). Use NULL to specify that this function should not return until it is completed. + The address of a reference to the effect pool (see ). + The address of a reference to memory (see ) that contains effect compile errors, if there were any. + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DX10CreateEffectPoolFromMemory([None] const void* pData,[None] SIZE_T DataLength,[None] const char* pSrcFileName,[In, Buffer, Optional] const D3D10_SHADER_MACRO* pDefines,[None] ID3D10Include* pInclude,[None] const char* pProfile,[None] int HLSLFlags,[None] int FXFlags,[None] ID3D10Device* pDevice,[None] ID3DX10ThreadPump* pPump,[None] ID3D10EffectPool** ppEffectPool,[None] ID3D10Blob** ppErrors,[None] HRESULT* pHResult) + + + + Create an effect pool from a resource. + + A handle to the resource module containing the effect. HMODULE can be obtained with {{GetModuleHandle Function}}. + The name of the resource in hModule. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. + Optional. Effect file name, which is used for error messages only. Can be NULL. + A NULL-terminated array of shader macros (see ); set this to NULL to specify no macros. + A reference to an include interface (see ). This parameter can be NULL. + A string that specifies the {{shader profile}}, or shader model. + HLSL compile options (see {{D3D10_SHADER Constants}}). + Effect compile options (see {{Compile and Effect Flags}}). + A reference to the device (see ) that will use the resources. + A reference to a thread pump interface (see ). Use NULL to specify that this function should not return until it is completed. + The address of a reference to the effect pool (see ). + The address of a reference to memory (see ) that contains effect compile errors, if there were any. + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10CreateEffectPoolFromResourceW([None] void* hModule,[None] const wchar_t* pResourceName,[None] const wchar_t* pSrcFileName,[In, Buffer, Optional] const D3D10_SHADER_MACRO* pDefines,[None] ID3D10Include* pInclude,[None] const char* pProfile,[None] int HLSLFlags,[None] int FXFlags,[None] ID3D10Device* pDevice,[None] ID3DX10ThreadPump* pPump,[None] ID3D10EffectPool** ppEffectPool,[None] ID3D10Blob** ppErrors,[None] HRESULT* pHResult) + + + + A rasterizer-state interface accesses rasterizer state for the {{rasterizer stage}}. + + ID3D10RasterizerState + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the properties of a rasterizer-state object. + + Pointer to a rasterizer-state description (see ). + void ID3D10RasterizerState::GetDesc([Out] D3D10_RASTERIZER_DESC* pDesc) + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Get the properties of a rasterizer-state object. + + void ID3D10RasterizerState::GetDesc([Out] D3D10_RASTERIZER_DESC* pDesc) + + + + A {{1D texture}} interface accesses texel data, which is structured memory. + + ID3D10Texture1D + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a reference to the data contained in a subresource, and deny the GPU access to that subresource. + + + Mapping a texture enables the CPU to directly access the underlying data in the subresource of a texture. For the method to succeed, the texture being mapped must be created with the appropriate flags (see ), and its specified usage (see ) must be either D3D10_USAGE_DYNAMIC or D3D10_USAGE_STAGING. Common failures of Map methods are indicated by the following return values: ItemDescription DXGI_ERROR_WAS_STILL_DRAWING If MapFlags specifies D3D10_MAP_FLAG_DO_NOT_WAIT and the GPU is not yet finished with the resource, Map returns DXGI_ERROR_WAS_STILL_DRAWING. DXGI_ERROR_DEVICE_REMOVED Map returns DXGI_ERROR_DEVICE_REMOVED if MapType allows any CPU read access and the video card has been removed. ? For more information about the preceding return values, see . Map has the following restrictions: A single subresource cannot be mapped multiple times; in other words, do not call Map on a subresource that is already mapped. Any subresource that is bound to the pipeline must be unmapped before any render operation (that is, before ) can be executed. Applications must cast the void pData reference to the appropriate type to meaningfully access the underlying subresource data. For example, the following code demonstrates how to read each texel of a 1D subresource. It is assumed that the texture was created using and that pData is the reference to the texture resource data output from a successful call to this method. + FLOAT* pTexels = (FLOAT*)pData; + for( UINT col = 0; col < width; col++ ) + { pTexels[col*4 + 0]; // Alpha pTexels[col*4 + 1]; // Blue pTexels[col*4 + 2]; // Green pTexels[col*4 + 3]; // Red + } + + Differences between Direct3D 9 and Direct3D 10: Map in Direct3D 10 is analogous to resource {{Lock}} in Direct3D 9. ? + + Index number of the subresource. See {{D3D10CalcSubresource}} for more details. + Specifies the CPU's read and write permissions for a resource. For possible values, see . + that specifies what the CPU should do when the GPU is busy. This flag is optional. + Pointer to the texture resource data. + If this function succeeds, it returns S_OK. For other restrictions, and a listing of error values that can be returned by any of the Map methods, see Remarks. + HRESULT ID3D10Texture1D::Map([In] int Subresource,[In] D3D10_MAP MapType,[In] D3D10_MAP_FLAG MapFlags,[Out] void** ppData) + + + + Invalidate the reference to a resource that was retrieved by , and re-enable the GPU's access to that resource. + + + A subresource must be mapped before Unmap is called. Differences between Direct3D 9 and Direct3D 10: Unmap in Direct3D 10 is analogous to resource Unlock in Direct3D 9. ? + + to be unmapped. See {{D3D10CalcSubresource}} for more details. + void ID3D10Texture1D::Unmap([In] int Subresource) + + + + Get the properties of the texture resource. + + Pointer to a resource description (see ). + void ID3D10Texture1D::GetDesc([Out] D3D10_TEXTURE1D_DESC* pDesc) + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + The initial texture data. + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + An array of initial texture data for each subresource. + + + + Maps the texture, providing CPU access to its contents. + + The mip slice to map. + The IO operations to enable on the CPU. + Flags indicating how the CPU should respond when the GPU is busy. + A data stream containing the mapped data. This data stream is invalidated + when the buffer is unmapped. + + + + Get the properties of the texture resource. + + void ID3D10Texture1D::GetDesc([Out] D3D10_TEXTURE1D_DESC* pDesc) + + + + A {{2D texture}} interface manages texel data, which is structured memory. + + ID3D10Texture2D + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a reference to the data contained in a subresource, and deny GPU access to that subresource. + + Index number of the subresource. See {{D3D10CalcSubresource}} for more details. + Integer that specifies the CPU's read and write permissions for a resource. For possible values, see . + that specifies what the CPU should do when the GPU is busy. This flag is optional. + Pointer to a structure () that is filled in by the function and contains a reference to the resource data. + If this function succeeds, it returns S_OK. All of the Map methods have identical return values and operating restrictions. These are listed in the remarks section of . + HRESULT ID3D10Texture2D::Map([In] int Subresource,[In] D3D10_MAP MapType,[In] D3D10_MAP_FLAG MapFlags,[Out] D3D10_MAPPED_TEXTURE2D* pMappedTex2D) + + + + Invalidate the reference to the resource that was retrieved by , and re-enable GPU access to the resource. + + + A subresource must be mapped before Unmap is called. Differences between Direct3D 9 and Direct3D 10: Unmap in Direct3D 10 is analogous to resource Unlock in Direct3D 9. ? + + to be unmapped. See {{D3D10CalcSubresource}} for more details. + void ID3D10Texture2D::Unmap([In] int Subresource) + + + + Get the properties of the texture resource. + + Pointer to a resource description (see ). + void ID3D10Texture2D::GetDesc([Out] D3D10_TEXTURE2D_DESC* pDesc) + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + The initial texture data. + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + An array of initial texture data for each subresource. + + + + Converts a height map into a normal map. The (x,y,z) components of each normal are mapped to the (r,g,b) channels of the output texture. + + The source height map texture. + The destination texture. + One or more flags that control generation of normal maps. + One or more flag specifying the source of height information. + Constant value multiplier that increases (or decreases) the values in the normal map. Higher values usually make bumps more visible, lower values usually make bumps less visible. + A object describing the result of the operation. + + + + Maps the texture, providing CPU access to its contents. + + The mip slice to map. + The IO operations to enable on the CPU. + Flags indicating how the CPU should respond when the GPU is busy. + A data rectangle containing the mapped data. This data stream is invalidated when the buffer is unmapped. + + + + Get the properties of the texture resource. + + void ID3D10Texture2D::GetDesc([Out] D3D10_TEXTURE2D_DESC* pDesc) + + + + A {{3D texture}} interface accesses texel data, which is structured memory. + + ID3D10Texture3D + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a reference to the data contained in a subresource, and deny GPU access to that subresource. + + Index number of the subresource. See {{D3D10CalcSubresource}}for more details. + Specifies the CPU's read and write permissions for a resource. For possible values, see . + that specifies what the CPU should do when the GPU is busy. This flag is optional. + Pointer to a structure () that is filled in by the function and contains a reference to the resource data. + If this function succeeds, it returns S_OK. All of the Map methods have identical return values and operating restrictions. These are listed in the remarks section of . + HRESULT ID3D10Texture3D::Map([In] int Subresource,[In] D3D10_MAP MapType,[In] D3D10_MAP_FLAG MapFlags,[Out] D3D10_MAPPED_TEXTURE3D* pMappedTex3D) + + + + Invalidate the reference to the resource retrieved by , and re-enable the GPU's access to the resource. + + + A subresource must be mapped before Unmap is called. Differences between Direct3D 9 and Direct3D 10: Unmap() in Direct3D 10 is analogous to resource Unlock() in Direct3D 9. ? + + to be unmapped. See {{D3D10CalcSubresource}} for more details. + void ID3D10Texture3D::Unmap([In] int Subresource) + + + + Get the properties of the texture resource. + + Pointer to a resource description (see ). + void ID3D10Texture3D::GetDesc([Out] D3D10_TEXTURE3D_DESC* pDesc) + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + The initial texture data. + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + An array of initial texture data for each subresource. + + + + Maps the texture, providing CPU access to its contents. + + The mip slice to map. + The IO operations to enable on the CPU. + Flags indicating how the CPU should respond when the GPU is busy. + A databox containing the mapped data. This data stream is invalidated when the buffer is unmapped. + + + + Get the properties of the texture resource. + + void ID3D10Texture3D::GetDesc([Out] D3D10_TEXTURE3D_DESC* pDesc) + + + + A shader-resource-view interface specifies the {{subresources}} a shader can access during rendering. Examples of shader resources include a constant buffer, a texture buffer, a texture or a sampler. + + ID3D10ShaderResourceView + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the shader resource view's description. + + A reference to a structure to be filled with data about the shader resource view. + void ID3D10ShaderResourceView::GetDesc([Out] D3D10_SHADER_RESOURCE_VIEW_DESC* pDesc) + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the ShaderResource flag. + ID3D10Device::CreateShaderResourceView + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the ShaderResource flag. + A structure describing the to be created. + ID3D10Device::CreateShaderResourceView + + + + Create a shader-resource view from a file. Read the characteristics of a texture when the texture is loaded. + + A reference to the device (see ) that will use the resource. + Name of the file that contains the shader-resource view. + Returns a reference to the shader-resource view (see ). + HRESULT D3DX10CreateShaderResourceViewFromFileW([None] ID3D10Device* pDevice,[None] const wchar_t* pSrcFile,[In, Optional] D3DX10_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX10ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a file. + + A reference to the device (see ) that will use the resource. + Name of the file that contains the shader-resource view. + Identifies the characteristics of a texture (see ) when the data processor is created. + Returns a reference to the shader-resource view (see ). + HRESULT D3DX10CreateShaderResourceViewFromFileW([None] ID3D10Device* pDevice,[None] const wchar_t* pSrcFile,[In, Optional] D3DX10_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX10ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a file in memory. + + A reference to the device (see ) that will use the resource. + Pointer to a memory location that contains the shader-resource view. + Returns a reference to the shader-resource view (see ). + HRESULT D3DX10CreateShaderResourceViewFromMemory([None] ID3D10Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX10_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX10ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a file in memory. + + A reference to the device (see ) that will use the resource. + Pointer to a memory location that contains the shader-resource view. + Identifies the characteristics of a texture (see ) when the data processor is created. + Returns a reference to the shader-resource view (see ). + HRESULT D3DX10CreateShaderResourceViewFromMemory([None] ID3D10Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX10_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX10ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a file in a stream.. + + A reference to the device (see ) that will use the resource. + Pointer to the file in memory that contains the shader-resource view. + Size of the file to read from the stream + Returns a reference to the shader-resource view (see ). + HRESULT D3DX10CreateShaderResourceViewFromMemory([None] ID3D10Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX10_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX10ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a file in a stream.. + + A reference to the device (see ) that will use the resource. + Pointer to the file in memory that contains the shader-resource view. + Size of the file to read from the stream + Identifies the characteristics of a texture (see ) when the data processor is created. + Returns a reference to the shader-resource view (see ). + HRESULT D3DX10CreateShaderResourceViewFromMemory([None] ID3D10Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX10_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX10ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Get the shader resource view's description. + + void ID3D10ShaderResourceView::GetDesc([Out] D3D10_SHADER_RESOURCE_VIEW_DESC* pDesc) + + + + A render-target-view interface identifies the render-target {{subresources}} that can be accessed during rendering. + + ID3D10RenderTargetView + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the properties of a render target view. + + Pointer to the description of a render target view (see ). + void ID3D10RenderTargetView::GetDesc([Out] D3D10_RENDER_TARGET_VIEW_DESC* pDesc) + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the RenderTarget flag. + ID3D10Device::CreateRenderTargetView + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the RenderTarget flag. + A structure describing the to be created. + ID3D10Device::CreateRenderTargetView + + + + Get the properties of a render target view. + + void ID3D10RenderTargetView::GetDesc([Out] D3D10_RENDER_TARGET_VIEW_DESC* pDesc) + + + + A vertex-shader interface manages an executable program (a vertex shader) that controls the {{vertex-shader stage}}. + + ID3D10VertexShader + + + + Initializes a new instance of the class. + + The native pointer. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + + + + A geometry-shader interface manages an executable program (a geometry shader) that controls the {{geometry-shader stage}}. + + ID3D10GeometryShader + + + + Initializes a new instance of the class. + + The native pointer. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + An array of instances describing the layout of the output buffers. + The size, in bytes, of each element in the array pointed to by pSODeclaration. This parameter is only used when the output slot is 0 for all entries in pSODeclaration. + + + + A pixel-shader interface manages an executable program (a pixel shader) that controls the {{pixel-shader stage}}. + + ID3D10PixelShader + + + + Initializes a new instance of the class. + + The native pointer. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + + + + An input-layout interface accesses the input data for the {{input-assembler stage}}. + + ID3D10InputLayout + + + + Initializes a new instance of the class. + + The native pointer. + + + + Initializes a new instance of the object to describe the + input-buffer data for the input-assembler stage. + + ID3D10Device::CreateInputLayout + The device used to create the layout. + An array of input elements describing the layout of the input data. + The compiled shader used to validate the input elements. + + + + Initializes a new instance of the object to describe the + input-buffer data for the input-assembler stage. + + ID3D10Device::CreateInputLayout + The device used to create the layout. + An array of input elements describing the layout of the input data. + The shader signature used to validate the input elements. + + + + A sampler-state interface accesses sampler state for a {{texture}}. + + ID3D10SamplerState + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the sampler state. + + A reference to the sampler state (see ). + void ID3D10SamplerState::GetDesc([Out] D3D10_SAMPLER_DESC* pDesc) + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Get the sampler state. + + void ID3D10SamplerState::GetDesc([Out] D3D10_SAMPLER_DESC* pDesc) + + + + A query interface queries information from the GPU. + + ID3D10Query + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a query description. + + Pointer to a query description (see ). + void ID3D10Query::GetDesc([Out] D3D10_QUERY_DESC* pDesc) + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The query description. + The newly created object. + + + + Get a query description. + + void ID3D10Query::GetDesc([Out] D3D10_QUERY_DESC* pDesc) + + + + A predicate interface determines whether geometry should be processed depending on the results of a previous draw call. + + ID3D10Predicate + + + + Initializes a new instance of the class. + + The native pointer. + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The query description. + The newly created object. + + + + A swith-to-reference interface (see the {{switch-to-reference}} layer) enables an application to switch between a hardware and software device. + + ID3D10SwitchToRef + + + + Initializes a new instance of the class. + + The native pointer. + + + + Switch between a hardware and a software device. + + + This API will fail if the device is not switchable; you must have created a device that is switchable by specifying the D3D10_CREATE_DEVICE_SWITCH_TO_REF flag during device creation (when calling ). Switching from a software device to a hardware device clears all cached objects from system memory. Switching from a hardware device to a software device causes resources to be downloaded to system memory. + + A boolean value. Set this to TRUE to change to a software device, set this to FALSE to change to a hardware device. + The previous value of UseRef. + BOOL ID3D10SwitchToRef::SetUseRef([None] BOOL UseRef) + + + + Get a boolean value that indicates the type of device being used. + + + A hardware device is commonly referred to as a HAL device, which stands for a hardware accelerated device. This means that the pipeline is rendering all of the pipeline commands in hardware, using the GPU. Operating the pipeline with a HAL device gives the best performance generally, but it can be more difficult to debug since resources exist on the GPU instead of the CPU. A software device implements rendering in software using the CPU with no hardware acceleration. A software device is commonly referred to as a reference device or REF device. Because a REF device implements rendering on the CPU, it is generally slower, but is easier to debug since it allows access to resources. + + TRUE if the device is a software device, FALSE if the device is a hardware device. See remarks. + BOOL ID3D10SwitchToRef::GetUseRef() + + + + Get a boolean value that indicates the type of device being used. + + + A hardware device is commonly referred to as a HAL device, which stands for a hardware accelerated device. This means that the pipeline is rendering all of the pipeline commands in hardware, using the GPU. Operating the pipeline with a HAL device gives the best performance generally, but it can be more difficult to debug since resources exist on the GPU instead of the CPU. A software device implements rendering in software using the CPU with no hardware acceleration. A software device is commonly referred to as a reference device or REF device. Because a REF device implements rendering on the CPU, it is generally slower, but is easier to debug since it allows access to resources. + + BOOL ID3D10SwitchToRef::GetUseRef() + + + + A state-block interface encapsulates render states. + + ID3D10StateBlock + + + + Initializes a new instance of the class. + + The native pointer. + + + + Capture the current value of states that are included in a stateblock. + + + Capture captures current values for states within an existing state block. It does not capture the entire state of the device. Creating an empty stateblock and calling Capture does nothing if no states have been set. + + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10StateBlock::Capture() + + + + Apply the state block to the current device state. + + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10StateBlock::Apply() + + + + Release all references to device objects. + + + Each time you return a reference to an interface (by calling ), the internal reference count is incremented; when you are finished using a stateblock, call this method to release all references and avoid a memory leak. + + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10StateBlock::ReleaseAllDeviceObjects() + + + + Get the device. + + Pointer to the ID3D10Device interface that is returned. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10StateBlock::GetDevice([Out] ID3D10Device** ppDevice) + + + + Create a state block. + + + A state block is a collection of device state, and is used for saving and restoring device state. Use a state-block mask to enable subsets of state for saving and restoring. The structure can be filled manually or by using any of the D3D10StateBlockMaskXXX APIs. A state block mask can also be obtained by calling or . Differences between Direct3D 9 and Direct3D 10: In Direct3D 10, a state block object does not contain any valid information about the state of the device until is called. In Direct3D 9, state is saved in a state block object, when it is created. ? + + The device for which the state block will be created. + Indicates which parts of the device state will be captured when calling and reapplied when calling . See remarks. + HRESULT D3D10CreateStateBlock([None] ID3D10Device* pDevice,[None] D3D10_STATE_BLOCK_MASK* pStateBlockMask,[None] ID3D10StateBlock** ppStateBlock) + + + + Get the device. + + HRESULT ID3D10StateBlock::GetDevice([Out] ID3D10Device** ppDevice) + + + + The ID3D10EffectType interface accesses effect variables by type. + + ID3D10EffectType + + + + Initializes a new instance of the class. + + The native pointer. + + + + Tests that the effect type is valid. + + TRUE if it is valid; otherwise FALSE. + BOOL ID3D10EffectType::IsValid() + + + + Get an effect-type description. + + + The effect-variable description contains data about the name, annotations, semantic, flags and buffer offset of the effect type. + + A reference to an effect-type description. See . + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectType::GetDesc([Out] D3D10_EFFECT_TYPE_DESC* pDesc) + + + + Get a member type by index. + + A zero-based index. + A reference to an . + ID3D10EffectType* ID3D10EffectType::GetMemberTypeByIndex([None] int Index) + + + + Get an member type by name. + + A member's name. + A reference to an . + ID3D10EffectType* ID3D10EffectType::GetMemberTypeByName([None] const char* Name) + + + + Get a member type by semantic. + + A semantic. + A reference to an . + ID3D10EffectType* ID3D10EffectType::GetMemberTypeBySemantic([None] const char* Semantic) + + + + Get the name of a member. + + A zero-based index. + The name of the member. + const char* ID3D10EffectType::GetMemberName([None] int Index) + + + + Get the semantic attached to a member. + + A zero-based index. + A string that contains the semantic. + const char* ID3D10EffectType::GetMemberSemantic([None] int Index) + + + + Tests that the effect type is valid. + + BOOL ID3D10EffectType::IsValid() + + + + Get an effect-type description. + + + The effect-variable description contains data about the name, annotations, semantic, flags and buffer offset of the effect type. + + HRESULT ID3D10EffectType::GetDesc([Out] D3D10_EFFECT_TYPE_DESC* pDesc) + + + + A constant-buffer interface accesses constant buffers or texture buffers. + + ID3D10EffectConstantBuffer + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set a constant-buffer. + + A reference to a constant-buffer interface. See . + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectConstantBuffer::SetConstantBuffer([None] ID3D10Buffer* pConstantBuffer) + + + + Get a constant-buffer. + + The address of a reference to a constant-buffer interface. See . + HRESULT ID3D10EffectConstantBuffer::GetConstantBuffer([Out] ID3D10Buffer** ppConstantBuffer) + + + + Set a texture-buffer. + + A reference to a shader-resource-view interface for accessing a texture buffer. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectConstantBuffer::SetTextureBuffer([None] ID3D10ShaderResourceView* pTextureBuffer) + + + + Get a texture-buffer. + + The address of a reference to a shader-resource-view interface for accessing a texture buffer. See . + HRESULT ID3D10EffectConstantBuffer::GetTextureBuffer([Out] ID3D10ShaderResourceView** ppTextureBuffer) + + + + A shader-variable interface accesses a shader variable. + + ID3D10EffectShaderVariable + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a shader description. + + A zero-based index. + A reference to a shader description (see ). + HRESULT ID3D10EffectShaderVariable::GetShaderDesc([None] int ShaderIndex,[Out] D3D10_EFFECT_SHADER_DESC* pDesc) + + + + Get a vertex shader. + + A zero-based index. + A reference to a . + HRESULT ID3D10EffectShaderVariable::GetVertexShader([None] int ShaderIndex,[Out] ID3D10VertexShader** ppVS) + + + + Get a geometry shader. + + A zero-based index. + A reference to a . + HRESULT ID3D10EffectShaderVariable::GetGeometryShader([None] int ShaderIndex,[Out] ID3D10GeometryShader** ppGS) + + + + Get a pixel shader. + + A zero-based index. + A reference to a . + HRESULT ID3D10EffectShaderVariable::GetPixelShader([None] int ShaderIndex,[Out] ID3D10PixelShader** ppPS) + + + + Get an input-signature description. + + + An effect contains one or more shaders; each shader has an input and output signature; each signature contains one or more elements (or parameters). The shader index identifies the shader and the element index identifies the element (or parameter) in the shader signature. + + A zero-based shader index. + A zero-based shader-element index. + A reference to a parameter description (see ). + HRESULT ID3D10EffectShaderVariable::GetInputSignatureElementDesc([None] int ShaderIndex,[None] int Element,[Out] D3D10_SIGNATURE_PARAMETER_DESC* pDesc) + + + + Get an output-signature description. + + + An effect contains one or more shaders; each shader has an input and output signature; each signature contains one or more elements (or parameters). The shader index identifies the shader and the element index identifies the element (or parameter) in the shader signature. + + A zero-based shader index. + A zero-based element index. + A reference to a parameter description (see ). + HRESULT ID3D10EffectShaderVariable::GetOutputSignatureElementDesc([None] int ShaderIndex,[None] int Element,[Out] D3D10_SIGNATURE_PARAMETER_DESC* pDesc) + + + + An ID3D10EffectTechnique interface is a collection of passes. + + ID3D10EffectTechnique + + + + Initializes a new instance of the class. + + The native pointer. + + + + Test a technique to see if it contains valid syntax. + + TRUE if the code syntax is valid; otherwise FALSE. + BOOL ID3D10EffectTechnique::IsValid() + + + + Get a technique description. + + A reference to a technique description (see ). + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectTechnique::GetDesc([Out] D3D10_TECHNIQUE_DESC* pDesc) + + + + Get an annotation by index. + + + Use an annotation to attach a piece of metadata to a technique. + + The zero-based index of the interface reference. + A reference to an . + ID3D10EffectVariable* ID3D10EffectTechnique::GetAnnotationByIndex([None] int Index) + + + + Get an annotation by name. + + + Use an annotation to attach a piece of metadata to a technique. + + Name of the annotation. + A reference to an . + ID3D10EffectVariable* ID3D10EffectTechnique::GetAnnotationByName([None] const char* Name) + + + + Get a pass by index. + + + A technique contains one or more passes; get a pass using a name or an index. + + A zero-based index. + A reference to a . + ID3D10EffectPass* ID3D10EffectTechnique::GetPassByIndex([None] int Index) + + + + Get a pass by name. + + + A technique contains one or more passes; get a pass using a name or an index. + + The name of the pass. + A reference to an . + ID3D10EffectPass* ID3D10EffectTechnique::GetPassByName([None] const char* Name) + + + + Compute a state-block mask to allow/prevent state changes. + + A reference to a state-block mask (see ). + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT ID3D10EffectTechnique::ComputeStateBlockMask([None] D3D10_STATE_BLOCK_MASK* pStateBlockMask) + + + + Test a technique to see if it contains valid syntax. + + BOOL ID3D10EffectTechnique::IsValid() + + + + Get a technique description. + + HRESULT ID3D10EffectTechnique::GetDesc([Out] D3D10_TECHNIQUE_DESC* pDesc) + + + + A shader-resource-view interface specifies the {{subresources}} a shader can access during rendering. Examples of shader resources include a constant buffer, a texture buffer, a texture or a sampler. + + ID3D10ShaderResourceView1 + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the shader resource view's description. + + + This method requires Windows Vista Service Pack 1. + + A reference to a structure to be filled with data about the shader resource view. + void ID3D10ShaderResourceView1::GetDesc1([Out] D3D10_SHADER_RESOURCE_VIEW_DESC1* pDesc) + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the ShaderResource flag. + ID3D10Device1::CreateShaderResourceView1 + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the ShaderResource flag. + A structure describing the to be created. + ID3D10Device1::CreateShaderResourceView1 + + + + Get the shader resource view's description. + + + This method requires Windows Vista Service Pack 1. + + void ID3D10ShaderResourceView1::GetDesc1([Out] D3D10_SHADER_RESOURCE_VIEW_DESC1* pDesc) + + + + The ID3DX10Sprite interface provides a set of methods that simplify the process of drawing sprites using Microsoft Direct3D. This interface can operate on a set of many sprites. + + ID3DX10Sprite + + + + Initializes a new instance of the class. + + The native pointer. + + + + Prepare a device for drawing sprites. + + + Every call to Begin must be matched with a call to . + + Flags that control how the sprites will be drawn. See . + If the method succeeds, the return value is S_OK. If the method fails, the return value can be one of the following: D3DERR_INVALIDCALL, D3DERR_OUTOFVIDEOMEMORY, D3DXERR_INVALIDDATA, E_OUTOFMEMORY. + HRESULT ID3DX10Sprite::Begin([None] D3DX10_SPRITE_FLAG flags) + + + + Add an array of sprites to the batch of sprites to be rendered. This must be called in between calls to and , and must be called before End to send all of the batched sprites to the device for rendering. This draw method is most useful when drawing a small number of sprites that you want buffered into a large batch, such as fonts. + + The array of sprites to draw. See . + The number of sprites in pSprites. + If the method succeeds, the return value is S_OK. If the method fails, the return value can be one of the following: D3DERR_INVALIDCALL, D3DXERR_INVALIDDATA. + HRESULT ID3DX10Sprite::DrawSpritesBuffered([In, Buffer] D3DX10_SPRITE* pSprites,[None] int cSprites) + + + + Force all batched sprites to be submitted to the device. Device states remain as they were after the last call to ID3DX10Sprite::Begin. The list of batched sprites is then cleared. + + If the method succeeds, the return value is S_OK. If the method fails, the following value will be returned: D3DERR_INVALIDCALL. + HRESULT ID3DX10Sprite::Flush() + + + + Draw an array of sprites. This will immediately send the sprites to the device for rendering, which is different from which only adds an array of sprites to a batch of sprites to be rendered when is called. This draw method is most useful when drawing a large number of sprites that have already been sorted on the CPU (or do not need to be sorted), such as in a particle system. This must be called in between calls to and . + + The array of sprites to draw. See . + The number of sprites in pSprites. + The size of the sprite structure you are passing into pSprites. Passing in 0 is the equivalent of passing in sizeof(D3DX10_SPRITE). + Reserved. + If the method succeeds, the return value is S_OK. If the method fails, the return value can be one of the following: D3DERR_INVALIDCALL, D3DXERR_INVALIDDATA. + HRESULT ID3DX10Sprite::DrawSpritesImmediate([In, Buffer] D3DX10_SPRITE* pSprites,[None] int cSprites,[None] int cbSprite,[None] int flags) + + + + Call this after ID3DX10Sprite::Flush. If D3DX10_SPRITE_SAVE_STATE was specified when ID3DX10Sprite::Begin was called, this API will restore the device state to how it was before ID3DX10Sprite::Begin was called. + + If the method succeeds, the return value is S_OK. If the method fails, the following value will be returned: D3DERR_INVALIDCALL. + HRESULT ID3DX10Sprite::End() + + + + Get the view transform that applies to all sprites. + + Pointer to a {{D3DX10MATRIX}} that will be set to the transform of the sprite from the original world space. + If the method succeeds, the return value is S_OK. If the method fails, the following value will be returned: D3DERR_INVALIDCALL. + HRESULT ID3DX10Sprite::GetViewTransform([Out] D3DXMATRIX* pViewTransform) + + + + Set the view transform that applies to all sprites. + + Pointer to a D3DXMATRIX that contains a transform of the sprite from the original world space. Use this transform to scale, rotate, or transform the sprite. + If the method succeeds, the return value is S_OK. If the method fails, the following value will be returned: D3DERR_INVALIDCALL. + HRESULT ID3DX10Sprite::SetViewTransform([None] D3DXMATRIX* pViewTransform) + + + + Get the sprite projection matrix that is applied to all sprites. + + Pointer to a {{D3DX10MATRIX}} that will be set to the sprite's projection matrix. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Sprite::GetProjectionTransform([Out] D3DXMATRIX* pProjectionTransform) + + + + Set the projection matrix for all sprites. + + The projection matrix to be used on all sprites. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Sprite::SetProjectionTransform([None] D3DXMATRIX* pProjectionTransform) + + + + Retrieve the device associated with the sprite object. + + + Calling this method will increase the internal reference count on the ID3D10Device interface. + + Address of a reference to an ID3D10Device interface, representing the Direct3D device object associated with the sprite object. + If the method succeeds, the return value is S_OK. If the method fails, the following value will be returned: D3DERR_INVALIDCALL. + HRESULT ID3DX10Sprite::GetDevice([Out] ID3D10Device** ppDevice) + + + + Create a sprite for drawing a 2D texture. + + A reference to the device (see ) that will draw the sprite. + The size of the vertex buffer, in number of sprites, that will be sent to the device when or is called. This should be a small number if you know you will be rendering a small number of sprites at a time (to save memory) and a large number if you know you will be rendering a large number of sprites at a time. The maximum value is 4096. If 0 is specified, the vertex buffer size will automatically be set to 4096. + HRESULT D3DX10CreateSprite([None] ID3D10Device* pDevice,[None] int cDeviceBufferSize,[None] LPD3DX10SPRITE* ppSprite) + + + + Add an array of sprites to the batch of sprites to be rendered. This must be called in between calls to and , and must be called before End to send all of the batched sprites to the device for rendering. This draw method is most useful when drawing a small number of sprites that you want buffered into a large batch, such as fonts. + + The array of sprites to draw. See . + If the method succeeds, the return value is S_OK. If the method fails, the return value can be one of the following: D3DERR_INVALIDCALL, D3DXERR_INVALIDDATA. + HRESULT ID3DX10Sprite::DrawSpritesBuffered([None] D3DX10_SPRITE* pSprites,[None] int cSprites) + + + + Draw an array of sprites. This will immediately send the sprites to the device for rendering, which is different from which only adds an array of sprites to a batch of sprites to be rendered when is called. This draw method is most useful when drawing a large number of sprites that have already been sorted on the CPU (or do not need to be sorted), such as in a particle system. This must be called in between calls to and . + + The array of sprites to draw. See . + If the method succeeds, the return value is S_OK. If the method fails, the return value can be one of the following: D3DERR_INVALIDCALL, D3DXERR_INVALIDDATA. + HRESULT ID3DX10Sprite::DrawSpritesImmediate([In, Buffer] D3DX10_SPRITE* pSprites,[None] int cSprites,[None] int cbSprite,[None] int flags) + + + + Get the view transform that applies to all sprites. + + HRESULT ID3DX10Sprite::GetViewTransform([Out] D3DXMATRIX* pViewTransform) + + + + Get the sprite projection matrix that is applied to all sprites. + + HRESULT ID3DX10Sprite::GetProjectionTransform([Out] D3DXMATRIX* pProjectionTransform) + + + + Retrieve the device associated with the sprite object. + + + Calling this method will increase the internal reference count on the ID3D10Device interface. + + HRESULT ID3DX10Sprite::GetDevice([Out] ID3D10Device** ppDevice) + + + + A mesh buffer is a buffer that contains data about a mesh. It can contain one of five different types of data: vertex data, index data, adjacency data, attribute data, or point rep data. The structure is used to access these five pieces of data through the following five APIs: , , , , or . + + ID3DX10MeshBuffer + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a reference to the mesh buffer memory to modify its contents. + + + Differences between Direct3D 9 and Direct3D 10: Map() in Direct3D 10 is analogous to resource Map() in Direct3D 9. ? + + Pointer to the buffer data. + Size of the buffer in bytes. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10MeshBuffer::Map([Out] void** ppData,[Out] SIZE_T* pSize) + + + + Unmap a buffer. + + + Differences between Direct3D 9 and Direct3D 10: Unmap() in Direct3D 10 is analogous to resource Unlock() in Direct3D 9. ? + + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10MeshBuffer::Unmap() + + + + Get the size of the mesh buffer, in bytes. + + The size of the mesh buffer, in bytes. + SIZE_T ID3DX10MeshBuffer::GetSize() + + + + Get a reference to the mesh buffer memory to modify its contents. + + + Differences between Direct3D 9 and Direct3D 10: Map() in Direct3D 10 is analogous to resource Map() in Direct3D 9. ? + + Returns a reference to the mesh buffer memory to modify its contents + HRESULT ID3DX10MeshBuffer::Map([Out] void** ppData,[Out] SIZE_T* pSize) + + + + Get the size of the mesh buffer, in bytes. + + SIZE_T ID3DX10MeshBuffer::GetSize() + + + + Applications use the methods of the ID3DX10Mesh interface to manipulate mesh objects. + + ID3DX10Mesh + + + + Initializes a new instance of the class. + + The native pointer. + + + + Retrieves the number of faces in the mesh. + + Returns the number of faces in the mesh. + int ID3DX10Mesh::GetFaceCount() + + + + Get the number of vertices in the mesh. A mesh may contain multiple vertex buffers (i.e. one vertex buffer may contain all position data, another may contains all texture coordinate data, etc.), however each vertex buffer will contain the same number of elements. + + The number of vertices in the mesh. + int ID3DX10Mesh::GetVertexCount() + + + + Get the number of vertex buffers in the mesh. + + The number of vertex buffers in the mesh. + int ID3DX10Mesh::GetVertexBufferCount() + + + + Access the mesh's creation flags. + + The creation flags passed into the options parameter of when the mesh was created. See {{D3DX10_MESH}}. + int ID3DX10Mesh::GetFlags() + + + + Access the vertex description passed into . The vertex description describes the layout of the mesh's vertex buffers. + + Array of input elements that describe the layout of the mesh's vertex buffers. See . + The number of input elements in ppDesc. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::GetVertexDescription([Out, Buffer] const D3D10_INPUT_ELEMENT_DESC** ppDesc,[None] int* pDeclCount) + + + + Set vertex data into one of the mesh's vertex buffers. + + The vertex buffer to be filled with pData. + The vertex data to set. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::SetVertexData([None] int iBuffer,[None] const void* pData) + + + + Retrieves the vertex buffer associated with the mesh. + + The vertex buffer to get. This is an index value. + The vertex buffer. See + HRESULT ID3DX10Mesh::GetVertexBuffer([None] int iBuffer,[None] ID3DX10MeshBuffer** ppVertexBuffer) + + + + Set the mesh's index data. + + The index data. + The number of indices in pData. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::SetIndexData([None] const void* pData,[None] int cIndices) + + + + Retrieves the data in an index buffer. + + Address of a reference to a ID3DX10MeshBuffer interface, representing the index buffer associated with the mesh. + HRESULT ID3DX10Mesh::GetIndexBuffer([None] ID3DX10MeshBuffer** ppIndexBuffer) + + + + Set the mesh's attribute data. + + The attribute data to set. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::SetAttributeData([In] const void* pData) + + + + Access the mesh's attribute buffer. + + The attribute buffer. See . + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::GetAttributeBuffer([None] ID3DX10MeshBuffer** ppAttributeBuffer) + + + + Sets the attribute table for a mesh and the number of entries stored in the table. + + + If an application keeps track of the information in an attribute table, and rearranges the table as a result of changes to attributes or faces, this method allows the application to update the attribute tables instead of calling ID3DX10Mesh::Optimize again. + + Pointer to an array of D3DX10_ATTRIBUTE_RANGE structures, representing the entries in the mesh attribute table. + Number of attributes in the mesh attribute table. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::SetAttributeTable([In, Buffer] const D3DX10_ATTRIBUTE_RANGE* pAttribTable,[None] int cAttribTableSize) + + + + Retrieves either an attribute table for a mesh, or the number of entries stored in an attribute table for a mesh. + + + An attribute table is used to identify areas of the mesh that need to be drawn with different textures, render states, materials, and so on. In addition, the application can use the attribute table to hide portions of a mesh by not drawing a given attribute identifier when drawing the frame. + + Pointer to an array of D3DX10_ATTRIBUTE_RANGE structures, representing the entries in the mesh's attribute table. Specify NULL to retrieve the value for pAttribTableSize. + Pointer to either the number of entries stored in pAttribTable or a value to be filled in with the number of entries stored in the attribute table for the mesh. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::GetAttributeTable([Out, Buffer, Optional] D3DX10_ATTRIBUTE_RANGE* pAttribTable,[None] int* pAttribTableSize) + + + + Generate a list of mesh edges, as well as a list of faces that share each edge. + + + After an application generates adjacency information for a mesh, the mesh data can be optimized for better drawing performance. The order of the entries in the adjacency buffer is determined by the order of the vertex indices in the index buffer. The adjacent triangle 0 always corresponds to the edge between the indices of the corners 0 and 1. The adjacent triangle 1 always corresponds to the edge between the indices of the corners 1 and 2 while the adjacent triangle 2 corresponds to the edge between the indices of the corners 2 and 0. + + Specifies that vertices that differ in position by less than epsilon should be treated as coincident. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::GenerateAdjacencyAndPointReps([None] float Epsilon) + + + + Adds adjacency data to the mesh's index buffer. When the mesh is to be sent to a geometry shader that takes adjacency data, it is neccessary for the mesh's index buffer to contain adjacency data. + + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::GenerateGSAdjacency() + + + + Set the mesh's adjacency data. + + The adjacency data to set. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::SetAdjacencyData([In] const void* pAdjacency) + + + + Access the mesh's adjacency buffer. + + The adjacency buffer. See . + HRESULT ID3DX10Mesh::GetAdjacencyBuffer([None] ID3DX10MeshBuffer** ppAdjacency) + + + + Set the point rep data for the mesh. + + The point rep data to set. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::SetPointRepData([In] const void* pPointReps) + + + + Get the mesh's point rep buffer. + + Pointer to a mesh buffer containing the mesh's point rep data. See . + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::GetPointRepBuffer([None] ID3DX10MeshBuffer** ppPointReps) + + + + Removes mesh data from the device that has been committed to the device (with ). + + Specifies which pieces of mesh data to discard from the device. See . + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::Discard([None] D3DX10_MESH_DISCARD_FLAGS dwDiscard) + + + + Creates a new mesh and fills it with the data of a previously loaded mesh. + + Creation flags to be applied to the new mesh. See {{D3DX10_MESH}}. + The semantic name for the position data. + Array of D3D10_INPUT_ELEMENT_DESC structures, describing the vertex format for the returned mesh. See . + The number of elements in the pDesc array. + The new mesh. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::CloneMesh([None] int Flags,[None] const char* pPosSemantic,[In, Buffer] const D3D10_INPUT_ELEMENT_DESC* pDesc,[None] int DeclCount,[None] ID3DX10Mesh** ppCloneMesh) + + + + Generates a new mesh with reordered faces and vertices to optimize drawing performance. + + + This method generates a new mesh. Before running Optimize, an application must generate an adjacency buffer by calling . The adjacency buffer contains adjacency data, such as a list of edges and the faces that are adjacent to each other. This method is very similar to the method, except that it can perform optimization while generating the new clone of the mesh. The output mesh inherits all of the creation parameters of the input mesh. + + Specifies the type of optimization to perform. This parameter can be set to a combination of one or more flags from D3DXMESHOPT and D3DXMESH (except D3DXMESH_32BIT, D3DXMESH_IB_WRITEONLY, and D3DXMESH_WRITEONLY). + An array of UINTs, one per face, that identifies the original mesh face that corresponds to each face in the optimized mesh. If the value supplied for this argument is NULL, face remap data is not returned. + Address of a reference to an , which contains a DWORD for each vertex that specifies how the new vertices map to the old vertices. This remap is useful if you need to alter external data based on the new vertex mapping. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::Optimize([None] int Flags,[Out, Buffer, Optional] int* pFaceRemap,[In] void* ppVertexRemap) + + + + Generate an attribute buffer from the data in the mesh's attribute table. An attribute buffer is another format for storing the data in the attribute table. Both the attribute buffer and the attribute table are internal data structures in the mesh. + + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::GenerateAttributeBufferFromTable() + + + + Determines if a ray intersects with this mesh. + + + This API provides a way to understand points in and around a triangle, independent of where the triangle is actually located. This function returns the resulting point by using the following equation: V1 + U(V2 - V1) + V(V3 - V1). Any point in the plane V1V2V3 can be represented by the barycentric coordinate (U,V). The parameter U controls how much V2 gets weighted into the result, and the parameter V controls how much V3 gets weighted into the result. Lastly, the value of [1 - (U + V)] controls how much V1 gets weighted into the result. Barycentric coordinates are a form of general coordinates. In this context, using barycentric coordinates represents a change in coordinate systems. What holds true for Cartesian coordinates holds true for barycentric coordinates. Barycentric coordinates define a point inside a triangle in terms of the triangle's vertices. For a more in-depth description of barycentric coordinates, see {{Mathworld's Barycentric Coordinates Description}}. + + Pointer to a structure, specifying the point where the ray begins. + Pointer to a structure, specifying the direction of the ray. + The number of times the ray intersected with the mesh. + Pointer to an index value of the face closest to the ray origin, if pHit is TRUE. + Pointer to a barycentric hit coordinate, U. + Pointer to a barycentric hit coordinate, V. + Pointer to a ray intersection parameter distance. + Pointer to an , containing an array of {{D3DX10_INTERSECT_INFO}} structures. This is a list of all the hits that occurred in the intersection test. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::Intersect([None] D3DXVECTOR3* pRayPos,[None] D3DXVECTOR3* pRayDir,[None] int* pHitCount,[None] int* pFaceIndex,[None] float* pU,[None] float* pV,[None] float* pDist,[None] ID3D10Blob** ppAllHits) + + + + Determines if a ray intersects with a subset of this mesh. + + + This API provides a way to understand points in and around a triangle, independent of where the triangle is actually located. This function returns the resulting point by using the following equation: V1 + U(V2 - V1) + V(V3 - V1). Any point in the plane V1V2V3 can be represented by the barycentric coordinate (U,V). The parameter U controls how much V2 gets weighted into the result, and the parameter V controls how much V3 gets weighted into the result. Lastly, the value of [1 - (U + V)] controls how much V1 gets weighted into the result. Barycentric coordinates are a form of general coordinates. In this context, using barycentric coordinates represents a change in coordinate systems. What holds true for Cartesian coordinates holds true for barycentric coordinates. Barycentric coordinates define a point inside a triangle in terms of the triangle's vertices. For a more in-depth description of barycentric coordinates, see {{Mathworld's Barycentric Coordinates Description}}. + + Attribute ID indentifying the subset of the mesh. + Pointer to a structure, specifying the point where the ray begins. + Pointer to a structure, specifying the direction of the ray. + The number of times the ray intersected with the mesh. + Pointer to an index value of the face closest to the ray origin, if pHit is TRUE. + Pointer to a barycentric hit coordinate, U. + Pointer to a barycentric hit coordinate, V. + Pointer to a ray intersection parameter distance. + Pointer to an , containing an array of {{D3DX10_INTERSECT_INFO}} structures. This is a list of all the hits that occurred in the intersection test. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::IntersectSubset([None] int AttribId,[None] D3DXVECTOR3* pRayPos,[None] D3DXVECTOR3* pRayDir,[None] int* pHitCount,[None] int* pFaceIndex,[None] float* pU,[None] float* pV,[None] float* pDist,[None] ID3D10Blob** ppAllHits) + + + + Commit any changes made to a mesh to the device so that the changes can be rendered. This should be called after a mesh's data is altered and before it is rendered. A mesh cannot be rendered unless it is committed to the device. See remarks. + + + When a mesh is loaded, it's data is loaded into staging resources, meaning the data can be altered but not rendered. When CommitToDevice is called, the data from the staging resources are copied into device resources so that they can be rendered. Although the data is committed to the device, the staging resources remain and can be modified. If any modifications are made to the staging resources, the staging resources must be committed to the device again in order for those changes to be rendered on screen. + + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::CommitToDevice() + + + + Draws a subset of a mesh. + + + An attribute table is used to identify areas of the mesh that need to be drawn with different textures, render states, materials, and so on. In addition, the application can use the attribute table to hide portions of a mesh by not drawing a given attribute identifier (AttribId) when drawing the frame. + + Specifies which subset of the mesh to draw. This value is used to differentiate faces in a mesh as belonging to one or more attribute groups. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::DrawSubset([None] int AttribId) + + + + Draw several instances of the same subset of a mesh. + + + A mesh contains an attribute table. The attribute table can divide a mesh into subsets, where each subset is identified with an attribute ID. For example, a mesh with 200 faces, divided into three subsets, might have an attribute table that looks like this: AttribID 0Faces 0 ~ 50 AttribID 1Faces 51 ~ 125 AttribID 2Faces 126 ~ 200 ? Instancing may extend performance by reusing the same geometry to draw multiple objects in a scene. One example of instancing could be to draw the same object with different positions and colors. Indexing requires multiple vertex buffers: at least one for per-vertex data and a second buffer for per-instance data. Drawing instances with DrawSubsetInstanced is very similar to the process used with that is outlined in {{Instancing Sample}}. The key difference when using DrawSubsetInstanced is that vertex and index buffers must be extracted from the object before the instancing data can be combined. The following code illustrates extracting the vertex and index buffers from the mesh object. + ID3D10Buffer* vertexBuffer; pDeviceObj->pMesh->GetDeviceVertexBuffer(0, &vertexBuffer); ID3D10Buffer* indexBuffer; pDeviceObj->pMesh->GetDeviceIndexBuffer(&indexBuffer); + + + + Specifies which subset of the mesh to draw. This value is used to differentiate faces in a mesh as belonging to one or more attribute groups. See remarks. + Number of instances to render. + Which instance to start fetching from in each buffer marked as instance data. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::DrawSubsetInstanced([None] int AttribId,[None] int InstanceCount,[None] int StartInstanceLocation) + + + + Access the mesh's vertex buffer after it has been committed to the device with . This is different from , which returns the vertex buffer before it has been committed to the device. + + An index identifying which vertex buffer to access. + The vertex buffer after it has been committed to the device. + HRESULT ID3DX10Mesh::GetDeviceVertexBuffer([None] int iBuffer,[None] ID3D10Buffer** ppVertexBuffer) + + + + Access the mesh's index buffer after it has been committed to the device with . This is different from , which returns the index buffer before it has been committed to the device. + + + If the mesh's index buffer has not already been committed to the device, this API will automatically commit the index buffer before it returns a reference to the buffer. + + The index buffer after it has been committed to the device. + HRESULT ID3DX10Mesh::GetDeviceIndexBuffer([None] ID3D10Buffer** ppIndexBuffer) + + + + Creates a mesh object using a declarator. + + Pointer to an , the device object to be associated with the mesh. + Array of elements, describing the vertex format for the returned mesh. This parameter must map directly to a flexible vertex format (FVF). + Semantic that identifies which part of the vertex declaration contains position information. + Number of vertices for the mesh. This parameter must be greater than 0. + Number of faces for the mesh. The valid range for this number is greater than 0, and one less than the maximum DWORD (typically 65534), because the last index is reserved. + Combination of one or more flags from the , specifying options for the mesh. + HRESULT D3DX10CreateMesh([None] ID3D10Device* pDevice,[In, Buffer] const D3D10_INPUT_ELEMENT_DESC* pDeclaration,[None] int DeclCount,[None] const char* pPositionSemantic,[None] int VertexCount,[None] int FaceCount,[None] int Options,[None] ID3DX10Mesh** ppMesh) + + + + Creates a new mesh and fills it with the data of a previously loaded mesh. + + The semantic name for the position data. + Array of structures, describing the vertex format for the returned mesh. See . + Creation flags to be applied to the new mesh. See . + returns the Mesh cloned. + HRESULT ID3DX10Mesh::CloneMesh([None] int Flags,[None] const char* pPosSemantic,[In, Buffer] const D3D10_INPUT_ELEMENT_DESC* pDesc,[None] int DeclCount,[None] ID3DX10Mesh** ppCloneMesh) + + + + Access the mesh's attribute buffer. + + Returns the attribute buffer. See . + HRESULT ID3DX10Mesh::GetAttributeBuffer([None] ID3DX10MeshBuffer** ppAttribute) + + + + Retrieves either an attribute table for a mesh, or the number of entries stored in an attribute table for a mesh. + + + An attribute table is used to identify areas of the mesh that need to be drawn with different textures, render states, materials, and so on. In addition, the application can use the attribute table to hide portions of a mesh by not drawing a given attribute identifier when drawing the frame. + + Returns an array of structures, representing the entries in the mesh's attribute table. + HRESULT ID3DX10Mesh::GetAttributeTable([Out, Buffer, Optional] D3DX10_ATTRIBUTE_RANGE* pAttribTable,[None] int* pAttribTableSize) + + + + Get the mesh's point rep buffer. + + Returns a mesh buffer containing the mesh's point rep data. See . + HRESULT ID3DX10Mesh::GetPointRepBuffer([None] ID3DX10MeshBuffer** ppPointReps) + + + + Optimizes the mesh data. + + Flags indicating which optimizations to perform. + A result code. + + + + Generates a new mesh with reordered faces and vertices to optimize drawing performance. + + + This method generates a new mesh. Before running Optimize, an application must generate an adjacency buffer by calling . The adjacency buffer contains adjacency data, such as a list of edges and the faces that are adjacent to each other. This method is very similar to the method, except that it can perform optimization while generating the new clone of the mesh. The output mesh inherits all of the creation parameters of the input mesh. + + Specifies the type of optimization to perform. This parameter can be set to a combination of one or more flags from D3DXMESHOPT and D3DXMESH (except D3DXMESH_32BIT, D3DXMESH_IB_WRITEONLY, and D3DXMESH_WRITEONLY). + An array of UINTs, one per face, that identifies the original mesh face that corresponds to each face in the optimized mesh. + An array of index for each vertex that specifies how the new vertices map to the old vertices. This remap is useful if you need to alter external data based on the new vertex mapping. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::Optimize([None] int Flags,[Out, Buffer, Optional] int* pFaceRemap,[In] LPD3D10BLOB* ppVertexRemap) + + + + Set the mesh's adjacency data. + + The adjacency data to set + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::SetAdjacencyData([In] const int* pAdjacency) + + + + Set the mesh's attribute data. + + The attribute data to set. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::SetAttributeData([In] const int* pData) + + + + Sets the attribute table for a mesh and the number of entries stored in the table. + + + If an application keeps track of the information in an attribute table, and rearranges the table as a result of changes to attributes or faces, this method allows the application to update the attribute tables instead of calling ID3DX10Mesh::Optimize again. + + an array of structures, representing the entries in the mesh attribute table. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::SetAttributeTable([In, Buffer] const D3DX10_ATTRIBUTE_RANGE* pAttribTable,[None] int cAttribTableSize) + + + + Set the mesh's index data. + + The index data. + The number of indices in pData. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::SetIndexData([None] const void* pData,[None] int cIndices) + + + + Set the point rep data for the mesh. + + The point rep data to set. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::SetPointRepData([None] const int* pPointReps) + + + + Set vertex data into one of the mesh's vertex buffers. + + The vertex buffer to be filled with pData. + The vertex data to set. + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT ID3DX10Mesh::SetVertexData([None] int iBuffer,[None] const void* pData) + + + + Retrieves the number of faces in the mesh. + + int ID3DX10Mesh::GetFaceCount() + + + + Get the number of vertices in the mesh. A mesh may contain multiple vertex buffers (i.e. one vertex buffer may contain all position data, another may contains all texture coordinate data, etc.), however each vertex buffer will contain the same number of elements. + + int ID3DX10Mesh::GetVertexCount() + + + + Access the mesh's creation flags. + + The creation flags passed into the options parameter of when the mesh was created. See {{D3DX10_MESH}}. + int ID3DX10Mesh::GetFlags() + + + + ID3DX10SkinInfo allows you to optimize, process, and manually set the relationship between bones and vertices in your meshes (see {{Skeletal Animation on Wikipedia}}). It is most useful for making .x files exported by DCC Apps (such as 3DS Max and Maya) more hardware-friendly, and for improving the render speed of your skinned meshes in software render mode. + + ID3DX10SkinInfo + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the number of vertices in ID3DX10SkinInfo. + + The number of vertices in ID3DX10SkinInfo. + int ID3DX10SkinInfo::GetNumVertices() + + + + Get the number of bones in ID3DX10SkinInfo. + + The number of bones in ID3DX10SkinInfo. + int ID3DX10SkinInfo::GetNumBones() + + + + Get the number of vertices a bone can maximally influence. + + The number of vertices a bone can maximally influence. + int ID3DX10SkinInfo::GetMaxBoneInfluences() + + + + Allocate space for additional vertices. + + The number of vertices to add. + If this method succeeds, the return value is S_OK. If the method fails, the return value can be: E_OUTOFMEMORY. + HRESULT ID3DX10SkinInfo::AddVertices([None] int Count) + + + + Change which vertices are influenced by which bones. + + The new number of vertices. + A reference to an array of vertex indices, which describe the remapping. For example, say SkinInfo contains some vertices such that bone0 is mapped to v0, bone1 to v1, and bone2 to v2, and array with 2,1,0 is specified for pBoneRemap. This will cause bone0 to be mapped to v2, bone1 to v1, and bone2 to v0. + If the method succeeds, the return value is S_OK. If the method fails, the return value can be: E_OUTOFMEMORY or E_INVALIDARG. + HRESULT ID3DX10SkinInfo::RemapVertices([None] int NewVertexCount,[In, Buffer] int* pVertexRemap) + + + + Allocate space for more bones. + + The number of bones to add. + If this method succeeds, the return value is S_OK. If the method fails, the return value can be: E_OUTOFMEMORY. + HRESULT ID3DX10SkinInfo::AddBones([None] int Count) + + + + Remove a bone. + + An index that specifies which bone to remove. Must be between 0 and the value returned by . + If the method succeeds, the return value is S_OK. If the method fails, the return value can be: E_INVALIDARG. + HRESULT ID3DX10SkinInfo::RemoveBone([None] int Index) + + + + Change which bones influence which vertices. + + The new number of bones. + A reference to an array of bone indices, which describe the remapping. For example, say SkinInfo contains some bones such that bone0 is mapped to v0, bone1 to v1, and bone2 to v2, and array with 2,1,0 is specified for pBoneRemap. This will cause bone0 to be mapped to v2, bone1 to v1, and bone2 to v0. + If the method succeeds, the return value is S_OK. If the method fails, the return value can be: E_OUTOFMEMORY or E_INVALIDARG. + HRESULT ID3DX10SkinInfo::RemapBones([None] int NewBoneCount,[In, Buffer] int* pBoneRemap) + + + + Enable an existing bone to influence a group of vertices and define how much influence the bone has on each vertex. + + An index that specifies an existing bone. Must be between 0 and the value returned by . + Number of vertices to add to the bone's influence. + Pointer to an array of vertex indices. Each member of this array has a corresponding member in pWeights, such that pIndices[i] corresponds to pWeights[i]. The corresponding value in pWeights[i] determines how much influence BoneIndex will have on the vertex indexed by pIndices[i]. The size of the pIndices array must be equal to or greater than InfluenceCount. + Pointer to an array of bone weights. Each member of this array has a corresponding member in pIndices, such that pWeights[i] corresponds to pIndices[i]. Each value in pWeights is between 0 and 1 and defines the amount of influence the bone has over each vertex. The size of pWeights must be equal to or greater than InfluenceCount. + If the method succeeds, the return value is S_OK. If the method fails, the return value can be: E_INVALIDARG or E_OUTOFMEMORY. + HRESULT ID3DX10SkinInfo::AddBoneInfluences([None] int BoneIndex,[None] int InfluenceCount,[In, Buffer] int* pIndices,[In, Buffer] float* pWeights) + + + + Clear a bone's list of vertices that it influences. + + An index that specifies an existing bone. Must be between 0 and the value returned by . + If the method succeeds, the return value is S_OK. If the method fails, the return value can be: E_INVALIDARG. + HRESULT ID3DX10SkinInfo::ClearBoneInfluences([None] int BoneIndex) + + + + Get the number of vertices that a given bone influences. + + An index that specifies an existing bone. Must be between 0 and the value returned by . + If the method succeeds, the return value is S_OK. If the method fails, the return value can be: E_INVALIDARG. + int ID3DX10SkinInfo::GetBoneInfluenceCount([None] int BoneIndex) + + + + Get a list of vertices that a given bone influences and a list of the amount of influence that bone has on each vertex. + + An index that specifies an existing bone. Must be between 0 and the value returned by . + An offset from the top of the bone's list of influenced vertices. This must be between 0 and the value returned by . + The number of indices and weights to retrieve. Must be between 0 and the value returned by ID3DX10SkinInfo::GetBoneInfluenceCount. + A list of indices into the vertex buffer, each one representing a vertex influenced by the bone. These values correspond to the values in pDestWeights, such that pDestIndices[i] corresponds to pDestWeights[i]. + A list of the amount of influence the bone has on each vertex. These values correspond to the values in pDestIndices, such that pDestWeights[i] corresponds to pDestIndices[i].f + If the method succeeds, the return value is S_OK. If the method fails, the return value can be: E_INVALIDARG or E_OUTOFMEMORY. + HRESULT ID3DX10SkinInfo::GetBoneInfluences([None] int BoneIndex,[None] int Offset,[None] int Count,[Out, Buffer] int* pDestIndices,[Out, Buffer] float* pDestWeights) + + + + Find the index that indicates where a given vertex is in a given bone's list of influenced vertices. + + An index that specifies an existing bone. Must be between 0 and the value returned by . + The index of the vertex in the vertex buffer. + The index of the vertex in the bone's list of influenced vertices. + If the method succeeds, the return value is S_OK. If the method fails, the return value can be: E_INVALIDARG. + HRESULT ID3DX10SkinInfo::FindBoneInfluenceIndex([None] int BoneIndex,[None] int VertexIndex,[None] int* pInfluenceIndex) + + + + Set the amount of influence a given bone has over a given vertex. + + An index that specifies an existing bone. Must be between 0 and the value returned by . + An index into the bone's list of vertices that it influences. + The amount of influence, between 0 and 1, that the bone has over the vertex. + If the method succeeds, the return value is D3D_OK. If the method fails, the return value can be E_INVALIDARG. + HRESULT ID3DX10SkinInfo::SetBoneInfluence([None] int BoneIndex,[None] int InfluenceIndex,[None] float Weight) + + + + Get the amount of influence a given bone has over a given vertex. + + + Use ID3DX10SkinInfo::GetBoneInfluenceCount to find out how many vertices the bone influences. + + An index that specifies an existing bone. Must be between 0 and the value returned by . + An index into the bone's list of vertices that it influences. + The amount of influence, between 0 and 1, that the bone has over the vertex. + If the method succeeds, the return value is D3D_OK. If the method fails, the return value can be E_INVALIDARG. + HRESULT ID3DX10SkinInfo::GetBoneInfluence([None] int BoneIndex,[None] int InfluenceIndex,[None] float* pWeight) + + + + Limit the number of bones that can influence a vertex and/or limit the amount of influence a bone can have on a vertex. + + The maximum number of bones that can influence any given vertex. This value is ignored if it is greater than the value returned by . + A flag describing how to scale the remaining weights on a given vertex after some have been chopped off by MinWeight. If D3DX10_SKININFO_NO_SCALING is specified, the weights will not be scaled at all. If D3DX10_SKININFO_SCALE_TO_1 is specified, the weights greater than MinWeight will be scaled up so that they add up to 1.0. If D3DX10_SKININFO_SCALE_TO_TOTAL is specified, the weights greater than MinWeight will be scaled up so that they add up to the original total. + The minimum percentage of influence, or weight, that any bone can have on any vertex. This value must be between 0 and 1. + If the method succeeds, the return value is S_OK. If the method fails, the return value can be: E_OUTOFMEMORY or E_INVALIDARG. + HRESULT ID3DX10SkinInfo::Compact([None] int MaxPerVertexInfluences,[None] int ScaleMode,[None] float MinWeight) + + + + Do software skinning on an array of vertices. + + + Here is an example of how to use software skinning: + //vertex definition + struct MyVertex + { D3DXVECTOR3 Position; D3DXVECTOR2 Weight; D3DXVECTOR2 TexCoord; + }; //create vertex data + const UINT numVertices = 16; + MyVertex vertices[numVertices] = {...}; + MyVertex destVertices[numVertices]; //create bone matrices + D3DXMATRIX boneMatrices[2]; + D3DXMatrixIdentity(&boneMatrices[0]); + D3DXMatrixRotationX(&boneMatrices[1], 3.14159f / 180.0f); //create bone indices and weights + UINT boneIndices[numVertices] = {...}; + float boneWeights[2][numVertices] = {...}; //create skin info, populate it with bones and vertices, and then map them to each other + ID3DX10SkinInfo *pSkinInfo = NULL; + D3DX10CreateSkinInfo(&pSkinInfo); + pSkinInfo->AddBones(2); + pSkinInfo->AddVertices(numVertices); + pSkinInfo->AddBoneInfluences(0, numVertices, boneIndices, boneWeights[0]); + pSkinInfo->AddBoneInfluences(1, numVertices, boneIndices, boneWeights[1]); //create channel desc + D3DX10_SKINNING_CHANNEL channelDesc; + channelDesc.SrcOffset = 0; + channelDesc.DestOffset = 0; + channelDesc.IsNormal = FALSE; //do the skinning + pSkinInfo->DoSoftwareSkinning(0, numVertices, vertices, sizeof(MyVertex), destVertices, sizeof(MyVertex), boneMatrices, NULL, &channelDesc, 1); + + + + A 0-based index into pSrcVertices. + Number of vertices to transform. + Pointer to an array of vertices to transform. + The size, in bytes, of a vertex in pSrcVertices. + Pointer to an array of vertices, which will be filled with the transformed vertices. + The size, in bytes, of a vertex in pDestVertices. + An array of matrices that will be used to transform the points mapped to each bone, such that the vertices mapped to bone[i] will be transformed by pBoneMatrices[i]. This array will be used to transform the matrices only if the IsNormal value in pChannelDescs is set to false, otherwise pInverseTransposeBoneMatrices will be used. + If this value is NULL, it will be set equal to pBoneMatrices. This array of matrices will be used to transform the vertices only if the IsNormal value in pChannelDescs is set to true, otherwise pBoneMatrices will be used. + Pointer to a D3DX10_SKINNING_CHANNEL structure, which determines the member of the vertex decl the software skinning will be done on. + The number of D3DX10_SKINNING_CHANNEL structures in pChannelDescs. + If the method succeeds, the return value is S_OK. If the method fails, the return value can be: E_INVALIDARG. + HRESULT ID3DX10SkinInfo::DoSoftwareSkinning([None] int StartVertex,[None] int VertexCount,[None] void* pSrcVertices,[None] int SrcStride,[None] void* pDestVertices,[None] int DestStride,[None] D3DXMATRIX* pBoneMatrices,[In, Optional] D3DXMATRIX* pInverseTransposeBoneMatrices,[None] D3DX10_SKINNING_CHANNEL* pChannelDescs,[None] int NumChannels) + + + + Get a list of vertices that a given bone influences and a list of the amount of influence that bone has on each vertex. + + An index that specifies an existing bone. Must be between 0 and the value returned by . + An offset from the top of the bone's list of influenced vertices. This must be between 0 and the value returned by . + The number of indices and weights to retrieve. Must be between 0 and the value returned by ID3DX10SkinInfo::GetBoneInfluenceCount. + A list of indices into the vertex buffer, each one representing a vertex influenced by the bone. These values correspond to the values in pDestWeights, such that pDestIndices[i] corresponds to pDestWeights[i]. + A list of the amount of influence the bone has on each vertex. These values correspond to the values in pDestIndices, such that pDestWeights[i] corresponds to pDestIndices[i].f + If the method succeeds, the return value is S_OK. If the method fails, the return value can be: E_INVALIDARG or E_OUTOFMEMORY. + HRESULT ID3DX10SkinInfo::GetBoneInfluences([None] int BoneIndex,[None] int Offset,[None] int Count,[Out, Buffer] int* pDestIndices,[Out, Buffer] float* pDestWeights) + + + + Get the number of vertices in ID3DX10SkinInfo. + + int ID3DX10SkinInfo::GetNumVertices() + + + + Get the number of bones in ID3DX10SkinInfo. + + int ID3DX10SkinInfo::GetNumBones() + + + + Get the number of vertices a bone can maximally influence. + + int ID3DX10SkinInfo::GetMaxBoneInfluences() + + + + A description of a single element for the {{input-assembler stage}}. + + + An input-layout object contains an array of structures, each structure defines one element being read from an input slot. Create an input-layout object by calling . For an example, see {{Create an input-layout object}}. + + D3D10_INPUT_ELEMENT_DESC + + + + The {{HLSL semantic}} associated with this element in a {{shader input-signature}}. + + const char* SemanticName + + + + The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic name matrix, however each of the four component would have different semantic indices (0, 1, 2, and 3). + + int SemanticIndex + + + + The data type of the element data. See . + + DXGI_FORMAT Format + + + + An integer value that identifies the input-assembler (see {{input slot}}). Valid values are between 0 and 15, defined in D3D10.h. + + int InputSlot + + + + Optional. Offset (in bytes) between each element. Use D3D10_APPEND_ALIGNED_ELEMENT for convenience to define the current element directly after the previous one, including any packing if necessary. + + int AlignedByteOffset + + + + Identifies the input data class for a single input slot (see ). + + D3D10_INPUT_CLASSIFICATION InputSlotClass + + + + The number of instances to draw before stepping one unit forward in a vertex buffer filled with instance data. Can be any unsigned integer value (0 means do not step) when the slot class is D3D10_INPUT_PER_INSTANCE_DATA; must be 0 when the slot class is D3D10_INPUT_PER_VERTEX_DATA. + + int InstanceDataStepRate + + + + Initializes a new instance of the struct. + + The HLSL semantic associated with this element in a shader input-signature. + The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic name matrix, however each of the four component would have different semantic indices (0, 1, 2, and 3). + The data type of the element data. + Offset (in bytes) between each element. Use AppendAligned for convenience to define the current element directly after the previous one, including any packing if necessary. + An integer value that identifies the input-assembler. Valid values are between 0 and 15. + Identifies the input data class for a single input slot. + The number of instances to draw using the same per-instance data before advancing in the buffer by one element. This value must be 0 for an element that contains per-vertex data. + + + + Initializes a new instance of the struct. + + The HLSL semantic associated with this element in a shader input-signature. + The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic name matrix, however each of the four component would have different semantic indices (0, 1, 2, and 3). + The data type of the element data. + Offset (in bytes) between each element. Use AppendAligned for convenience to define the current element directly after the previous one, including any packing if necessary. + An integer value that identifies the input-assembler. Valid values are between 0 and 15. + + + + Initializes a new instance of the struct. + + The HLSL semantic associated with this element in a shader input-signature. + The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic name matrix, however each of the four component would have different semantic indices (0, 1, 2, and 3). + The data type of the element data. + An integer value that identifies the input-assembler. Valid values are between 0 and 15. + + + + Returns a value that can be used for the offset parameter of an InputElement to indicate that the element + should be aligned directly after the previous element, including any packing if neccessary. + + A value used to align input elements. + D3D10_APPEND_ALIGNED_ELEMENT + + + + Description of a vertex element in a vertex buffer in an output slot. + + D3D10_SO_DECLARATION_ENTRY + + + + Type of output element. Possible values: "POSITION", "NORMAL", or "TEXCOORD0". + + const char* SemanticName + + + + Output element's zero-based index. Should be used if, for example, you have more than one texture coordinate stored in each vertex. + + int SemanticIndex + + + + Which component of the entry to begin writing out to. Valid values are 0 ~ 3. For example, if you only wish to output to the y and z components of a position, then StartComponent should be 1 and ComponentCount should be 2. + + byte StartComponent + + + + The number of components of the entry to write out to. Valid values are 1 ~ 4. For example, if you only wish to output to the y and z components of a position, then StartComponent should be 1 and ComponentCount should be 2. + + byte ComponentCount + + + + The output slot that contains the vertex buffer that contains this output entry. + + byte OutputSlot + + + + Initializes a new instance of the struct. + + Name of the semantic. + Index of the semantic. + The start component. + The component count. + The output slot. + + + + Defines the dimensions of a {{viewport}}. + + + In all cases, Width and Height must be ? 0 and TopLeftX + Width and TopLeftY + Height must be ? D3D10_VIEWPORT_BOUNDS_MAX. + + D3D10_VIEWPORT + + + + X position of the left hand side of the viewport. Ranges between D3D10_VIEWPORT_BOUNDS_MIN and D3D10_VIEWPORT_BOUNDS_MAX. + + int TopLeftX + + + + Y position of the top of the viewport. Ranges between D3D10_VIEWPORT_BOUNDS_MIN and D3D10_VIEWPORT_BOUNDS_MAX. + + int TopLeftY + + + + Width of the viewport. + + int Width + + + + Height of the viewport. + + int Height + + + + Minimum depth of the viewport. Ranges between 0 and 1. + + float MinDepth + + + + Maximum depth of the viewport. Ranges between 0 and 1. + + float MaxDepth + + + + Initializes a new instance of the structure. + + The X coordinate of the viewport. + The Y coordinate of the viewport. + The width of the viewport. + The height of the viewport. + The minimum Z distance of the viewport. + The maximum Z distance of the viewport. + + + + Initializes a new instance of the structure. + + The X coordinate of the viewport. + The Y coordinate of the viewport. + The width of the viewport. + The height of the viewport. + + + + Defines a 3D box. + + + The following diagram shows a 3D box, where the origin is the left, front, top corner. ? Diagram of a 3D box, where the origin is the left, front, top corner ? + + D3D10_BOX + + + + The x position of the left hand side of the box. + + int left + + + + The y position of the top of the box. + + int top + + + + The z position of the front of the box. + + int front + + + + The x position of the right hand side of the box. + + int right + + + + The y position of the bottom of the box. + + int bottom + + + + The z position of the back of the box. + + int back + + + + Describes the stencil operations that can be performed based on the results of {{stencil test}}. + + + The stencil operation can be set differently based on the outcome of the stencil test by using the StencilFunc member. This can be done for the {{stencil test}} portion of depth-stencil testing. The D3D10_DEPTH_STENCILOP_DESC structure is a member of the structure. + + D3D10_DEPTH_STENCILOP_DESC + + + + A member of the enumerated type that describes the stencil operation to perform when stencil testing fails. The default value is D3D10_STENCIL_OP_KEEP. + + D3D10_STENCIL_OP StencilFailOp + + + + A member of the enumerated type that describes the stencil operation to perform when stencil testing passes and depth testing fails. The default value is D3D10_STENCIL_OP_KEEP. + + D3D10_STENCIL_OP StencilDepthFailOp + + + + A member of the enumerated type that describes the stencil operation to perform when stencil testing and depth testing both pass. The default value is D3D10_STENCIL_OP_KEEP. + + D3D10_STENCIL_OP StencilPassOp + + + + A member of the enumerated type that describes how stencil data is compared against existing stencil data. The default value is D3D10_COMPARISON_ALWAYS. + + D3D10_COMPARISON_FUNC StencilFunc + + + + Describes depth-stencil state. + + + Depth-stencil state controls how {{depth-stencil}} testing is performed by the {{output-merger}} stage. The formats that support stenciling are DXGI_FORMAT_D24_UNORM_S8_UINT and DXGI_FORMAT_D32_FLOAT_S8X24_UINT. + + D3D10_DEPTH_STENCIL_DESC + + + + A member of the enumerated type that identifies a portion of the depth-stencil buffer that can be modified by depth data. The default value is D3D10_DEPTH_WRITE_MASK_ALL. + + D3D10_DEPTH_WRITE_MASK DepthWriteMask + + + + A member of the enumerated type that defines how depth data is compared against existing depth data. The default value is D3D10_COMPARISON_LESS + + D3D10_COMPARISON_FUNC DepthFunc + + + + A value that identifies a portion of the depth-stencil buffer for reading stencil data. The default value is D3D10_DEFAULT_STENCIL_READ_MASK. + + byte StencilReadMask + + + + A value that identifies a portion of the depth-stencil buffer for writing stencil data. The default value is D3D10_DEFAULT_STENCIL_WRITE_MASK. + + byte StencilWriteMask + + + + A structure that identifies how to use the results of the depth test and the stencil test for pixels whose surface normal is facing toward the camera. + + D3D10_DEPTH_STENCILOP_DESC FrontFace + + + + A structure that identifies how to use the results of the depth test and the stencil test for pixels whose surface normal is facing away from the camera. + + D3D10_DEPTH_STENCILOP_DESC BackFace + + + + A Boolean value that enables depth testing. The default value is TRUE. + + BOOL DepthEnable + + + + A Boolean value that enables stencil testing. The default value is FALSE. + + BOOL StencilEnable + + + + Describes the blend state. + + + To see how blending is done, see {{Output-Merger Stage (Direct3D 10)}}. These are the default values for blend state. StateDefault Value AlphaToCoverageEnableFALSE BlendEnable[8]FALSE (for all 8) SrcBlendD3D10_BLEND_ONE DestBlendD3D10_BLEND_ZERO BlendOpD3D10_BLEND_OP_ADD SrcBlendAlphaD3D10_BLEND_ONE DestBlendAlphaD3D10_BLEND_ZERO BlendOpAlphaD3D10_BLEND_OP_ADD RenderTargetWriteMask[8]D3D10_COLOR_WRITE_ENABLE_ALL (for all 8) ? + + D3D10_BLEND_DESC + + + + This {{blend option}} specifies the first RGB data source and includes an optional pre-blend operation. + + D3D10_BLEND SrcBlend + + + + This {{blend option}} specifies the second RGB data source and includes an optional pre-blend operation. + + D3D10_BLEND DestBlend + + + + This {{blend operation}} defines how to combine the RGB data sources. + + D3D10_BLEND_OP BlendOp + + + + This {{blend option}} specifies the first alpha data source and includes an optional pre-blend operation. Blend options that end in _COLOR are not allowed. + + D3D10_BLEND SrcBlendAlpha + + + + This {{blend option}} specifies the second alpha data source and includes an optional pre-blend operation. Blend options that end in _COLOR are not allowed. + + D3D10_BLEND DestBlendAlpha + + + + This {{blend operation}} defines how to combine the alpha data sources. + + D3D10_BLEND_OP BlendOpAlpha + + + + Determines whether or not to use {{alpha-to-coverage}} as a multisampling technique when setting a pixel to a rendertarget. + + BOOL AlphaToCoverageEnable + + + + Enable (or disable) blending. There are eight elements in this array; these correspond to the eight rendertargets that can be set to output-merger stage at one time. + + BOOL BlendEnable[8] + + + + A per-pixel write mask that allows control over which components can be written (see ). + + D3D10_COLOR_WRITE_ENABLE RenderTargetWriteMask[8] + + + + Describes the rasterizer state. + + + Rasterizer state defines the behavior of the {{rasterizer stage}}; to set rasterizer state, call . + + D3D10_RASTERIZER_DESC + + + + A member of the enumerated type that determines the fill mode to use when rendering. The default value is D3D10_FILL_SOLID. + + D3D10_FILL_MODE FillMode + + + + A member of the enumerated type that indicates whether triangles facing the specified direction are drawn. The default value is D3D10_CULL_BACK. + + D3D10_CULL_MODE CullMode + + + + Specifies the depth value added to a given pixel. The default value is 0. For more information, see {{Depth Bias}}. + + int DepthBias + + + + Specifies the maximum depth bias of a pixel. The default value is 0.0f. For more information, see {{Depth Bias}}. + + float DepthBiasClamp + + + + Specifies a scalar on a given pixel's slope. The default value is 0.0f. For more information, see {{Depth Bias}}. + + float SlopeScaledDepthBias + + + + Determines if a triangle is front-facing or back-facing. If this parameter is TRUE, then a triangle is considered front-facing if its vertices are counter-clockwise on the render target, and considered back-facing if they are clockwise. If this parameter is FALSE, then the opposite is true. The default value is FALSE. + + BOOL FrontCounterClockwise + + + + Enables or disables clipping based on distance. The default value is TRUE. + + BOOL DepthClipEnable + + + + Enable or disables scissor-rectangle culling. All pixels outside an active scissor rectangle are culled. The default value is FALSE. For more information, see {{Set the Scissor Rectangle}}. + + BOOL ScissorEnable + + + + Enables or disables multisample antialiasing. The default value is FALSE. + + BOOL MultisampleEnable + + + + Enable or disables line antialiasing. Note that this option only applies when alpha blending is enabled, you are drawing lines, and the MultisampleEnable member is FALSE. The default value is FALSE. + + BOOL AntialiasedLineEnable + + + + Specifies data for initializing a {{subresource}}. + + + This structure is used in calls to create buffers () and textures (, , and ). If the resource being created does not require a system-memory pitch or a system-memory-pitch slice, then you are free to use those members to pass size information which may help you when debugging a problem creating a resource. Note that an application should not rely on SysMemPitch being exactly equal to the number of texels in a line times the size of a texel. In some cases SysMemPitch will include padding to skip past additional data in a line. This could be padding for alignment or the texture could be a subsection of a larger texture. For example the D3D10_SUBRESOURCE_DATA structure could represent a 32 by 32 subsection of a 128 by 128 texture. The value for SysMemSlicePitch will reflect any padding included in SysMemPitch. + + D3D10_SUBRESOURCE_DATA + + + + Pointer to the initialization data. + + const void* pSysMem + + + + The distance (in bytes) from the beginning of one line of a texture to the next line. System-memory pitch is used only for 2D and 3D texture data as it is has no meaning for the other resource types. + + int SysMemPitch + + + + The distance (in bytes) from the beginning of one depth level to the next. System-memory-slice pitch is only used for 3D texture data as it has no meaning for the other resource types. + + int SysMemSlicePitch + + + + Describes a {{1D texture}}. + + + This structure is used in a call to . A helpful derived structure CD3D10_TEXTURE1D_DESC is declared in D3D10.h, to help create a texture description. + + D3D10_TEXTURE1D_DESC + + + + Texture width (in texels). The range is from 1 to D3D10_REQ_TEXTURE1D_U_DIMENSION (8192). + + int Width + + + + Number of subtextures (also called mipmap levels). Use 1 for a multisampled texture; or 0 to generate a full set of subtextures. + + int MipLevels + + + + Number of textures in the array. The range is from 1 to D3D10_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION (512). + + int ArraySize + + + + Texture format (see ). + + DXGI_FORMAT Format + + + + Value that identifies how the texture is to be read from and written to. The most common value is D3D10_USAGE-DEFAULT; see for all possible values. + + D3D10_USAGE Usage + + + + Flags (see ) for binding to {{pipeline}} stages. The flags can be combined by a logical OR. + + D3D10_BIND_FLAG BindFlags + + + + Flags (see ) to specify the types of CPU access allowed. Use 0 if CPU access is not required. These flags can be combined with a logical OR. + + D3D10_CPU_ACCESS_FLAG CPUAccessFlags + + + + Flags (see ) that identify other, less common resource options. Use 0 if none of these flags apply. These flags can be combined with a logical OR. + + D3D10_RESOURCE_MISC_FLAG MiscFlags + + + + Describes a {{2D texture}}. + + + This structure is used in a call to . A helpful derived structure CD3D10_TEXTURE2D_DESC is declared in D3D10.h, to help create a texture description. The device places some size restrictions (must be multiples of a minimum size) for a subsampled, {{block compressed}}, or bit-format resource. + + D3D10_TEXTURE2D_DESC + + + + Texture width (in texels). The range is from 1 to D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION (8192). For a texture cube-map, the range is from 1 to D3D10_REQ_TEXTURECUBE_DIMENSION (8192). For more information about restrictions, see Remarks. + + int Width + + + + Texture height (in texels). The range is from 1 to D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION (8192). For a texture cube-map, the range is from 1 to D3D10_REQ_TEXTURECUBE_DIMENSION (8192). For more information about restrictions, see Remarks. + + int Height + + + + Number of subtextures (also called mipmap levels). Use 1 for a multisampled texture; or 0 to generate a full set of subtextures. + + int MipLevels + + + + Number of textures in the texture array. The range is from 1 to D3D10_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION (512). For a texture cube-map, this value is a multiple of 6 (that is, 6 * the value in the NumCubes member of ), and the range is from 6 to D3D10_REQ_TEXTURECUBE_DIMENSION. + + int ArraySize + + + + Texture format (see ). + + DXGI_FORMAT Format + + + + Structure that specifies multisampling parameters for the texture. See . + + DXGI_SAMPLE_DESC SampleDesc + + + + Value that identifies how the texture is to be read from and written to. The most common value is D3D10_USAGE-DEFAULT; see for all possible values. + + D3D10_USAGE Usage + + + + Flags (see ) for binding to {{pipeline}} stages. The flags can be combined by a logical OR. + + D3D10_BIND_FLAG BindFlags + + + + Flags (see ) to specify the types of CPU access allowed. Use 0 if CPU access is not required. These flags can be combined with a logical OR. + + D3D10_CPU_ACCESS_FLAG CPUAccessFlags + + + + Flags (see ) that identify other, less common resource options. Use 0 if none of these flags apply. These flags can be combined with a logical OR. For a texture cube-map, set the flag. Cube-map arrays (that is, ArraySize > 6) require feature level . + + D3D10_RESOURCE_MISC_FLAG MiscFlags + + + + Provides access to {{subresource}} data in a 2D texture. + + + This structure is used in a call to {{Map}}. To illustrate the row pitch, assume an uncompressed 2D texture with mipmap levels, as shown in the following illustration. ? Illustration of an uncompressed 2D texture with mipmap levels ? Visualize the top-level texture drawn in a single plane like the following illustration. ? Illustration of a single plane ? However, the actual layout of each element in memory looks more like the following illustration. ? Illustration of the row pitch in memory ? For this example, the row pitch encompasses 5 elements (one row), whose size would be five times the number of bytes per element. Use row pitch to advance a reference between rows within a single 2D texture plane. Example To access data in, say, the third mipmap level, you must cast the pData reference as demonstrated in the following example for a floating-point texture. + D3D10_MAPPED_TEXTURE2D mappedTexture; + if( SUCCEEDED( pTexture->Map( D3D10CalcSubresource(2, 0, 3), D3D10_MAP_WRITE_DISCARD, 0, &mappedTexture ))) + { D3D10_TEXTURE2D_DESC desc; pTexture->GetDesc( &desc ); // Compute the width and height of the third mipmap level const UINT WIDTH = desc.Width >> 2; const UINT HEIGHT = desc.Height >> 2; FLOAT* pTexels = (FLOAT*)mappedTexture.pData; for( UINT row = 0; row < HEIGHT; row++ ) { UINT rowStart = row * mappedTexture.RowPitch/4; for( UINT col = 0; col < WIDTH; col++ ) { pTexels[rowStart + col*4 + 0]; // Red pTexels[rowStart + col*4 + 1]; // Green pTexels[rowStart + col*4 + 2]; // Blue pTexels[rowStart + col*4 + 3]; // Alpha } } pTexture->Unmap(D3D10CalcSubresource(2, 0, 3)); + } + + + + D3D10_MAPPED_TEXTURE2D + + + + Pointer to the data. + + void* pData + + + + The pitch, or width, or physical size (in bytes), of one row of an uncompressed texture. A block-compressed texture is encoded in 4x4 blocks (see {{virtual size vs physical size}}) ; therefore, RowPitch is the number of bytes in a block of 4x4 texels. + + int RowPitch + + + + Describes a {{3D texture}}. + + + This structure is used in a call to . A helpful derived structure CD3D10_TEXTURE3D_DESC is declared in D3D10.h, to help create a texture description. The device restricts the size of subsampled, block compressed (see {{Block Compression (Direct3D 10)}}), and bit format resources to be multiples of sizes specific to each format. + + D3D10_TEXTURE3D_DESC + + + + Texture width (in texels). The range is from 1 to D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION (2048). For more information about restrictions, see Remarks. + + int Width + + + + Texture height (in texels). The range is from 1 to D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION (2048). For more information about restrictions, see Remarks. + + int Height + + + + Texture depth (in texels). The range is from 1 to D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION (2048). + + int Depth + + + + Number of subtextures (also called mipmap levels). Use 1 for a multisampled texture; or 0 to generate a full set of subtextures. + + int MipLevels + + + + Texture format (see ). + + DXGI_FORMAT Format + + + + Value that identifies how the texture is to be read from and written to. The most common value is D3D10_USAGE-DEFAULT; see for all possible values. + + D3D10_USAGE Usage + + + + Flags (see ) for binding to {{pipeline}} stages. The flags can be combined by a logical OR. + + D3D10_BIND_FLAG BindFlags + + + + Flags (see ) to specify the types of CPU access allowed. Use 0 if CPU access is not required. These flags can be combined with a logical OR. + + D3D10_CPU_ACCESS_FLAG CPUAccessFlags + + + + Flags (see ) that identify other, less common resource options. Use 0 if none of these flags apply. These flags can be combined with a logical OR. + + D3D10_RESOURCE_MISC_FLAG MiscFlags + + + + Provides access to {{subresource}} data in a {{3D texture}}. + + + This structure is used to access subresource data when calling . To access data, you must cast the pData reference; see for an example. To illustrate pitch for an uncompressed texture, assume a 3D texture with mipmap levels, as shown in the following illustration. ? Illustration of a 3D texture with mipmap levels ? It is easiest to consider the top-level texture only, as shown in the following illustration. ? Illustration of only the top-level texture ? And then visualize the top-level texture redrawn as a series of 2D textures, each one having a different depth value. This yields several texture planes, as shown in the following illustration. ? Illustration of top-level texture drawn as 2D texture planes ? However, the actual layout of all the elements from all the texture planes looks more like the following illustration. ? Illustration of the row pitch and depth pitch in memory ? Use row pitch to advance a reference between rows within a single 2D texture plane; use depth pitch to advance a reference between 2D texture planes. + + D3D10_MAPPED_TEXTURE3D + + + + Pointer to the data. + + void* pData + + + + The pitch, or width, or physical size (in bytes) of one row of an uncompressed texture. Since a block-compressed texture is encoded in 4x4 blocks, the RowPitch for a compressed texture is the number of bytes in a block of 4x4 texels. See {{virtual size vs physical size}} for more information on block compression. + + int RowPitch + + + + The pitch or number of bytes in all rows for a single depth. + + int DepthPitch + + + + Describes a shader-resource view. + + + A view is a format-specific way to look at the data in a resource. The view determines what data to look at, and how it is cast when read. For more information about how views work, see {{Views}} When viewing a resource, the resource-view description must specify a typed format, that is compatible with the resource format. So that means that you cannot create a resource-view description using any format with _TYPELESS in the name. You can however view a typeless resource by specifying a typed format for the view. For example, a DXGI_FORMAT_R32G32B32_TYPELESS resource can be viewed with one of these typed formats: DXGI_FORMAT_R32G32B32_FLOAT, DXGI_FORMAT_R32G32B32_UINT, and DXGI_FORMAT_R32G32B32_SINT, since these typed formats are compatible with the typeless resource. Create a shader-resource-view description by calling . To view a shader-resource-view description, call . + + D3D10_SHADER_RESOURCE_VIEW_DESC + + + + The viewing {{format}}. See remarks. + + DXGI_FORMAT Format + + + + The resource type of the view. See . This should be the same as the resource type of the underlying resource. This parameter also determines which _SRV to use in the union below. + + D3D10_SRV_DIMENSION ViewDimension + + + + View the resource as a buffer using information from a shader-resource view (see ). + + D3D10_BUFFER_SRV Buffer + + + + View the resource as a 1D texture using information from a shader-resource view (see ). + + D3D10_TEX1D_SRV Texture1D + + + + View the resource as a 1D-texture array using information from a shader-resource view (see . + + D3D10_TEX1D_ARRAY_SRV Texture1DArray + + + + View the resource as a 2D-texture using information from a shader-resource view (see . + + D3D10_TEX2D_SRV Texture2D + + + + View the resource as a 2D-texture array using information from a shader-resource view (see . + + D3D10_TEX2D_ARRAY_SRV Texture2DArray + + + + View the resource as a 2D-multisampled texture using information from a shader-resource view (see . + + D3D10_TEX2DMS_SRV Texture2DMS + + + + View the resource as a 2D-multisampled-texture array using information from a shader-resource view (see . + + D3D10_TEX2DMS_ARRAY_SRV Texture2DMSArray + + + + View the resource as a 3D texture using information from a shader-resource view (see . + + D3D10_TEX3D_SRV Texture3D + + + + View the resource as a 3D-cube texture using information from a shader-resource view (see ). + + D3D10_TEXCUBE_SRV TextureCube + + + + Specifies the elements in a {{buffer}} resource to use in a shader-resource view. + + + The D3D10_BUFFER_SRV structure is a member of the structure, which represents a shader-resource view description. You can create a shader-resource view by calling the method. + + D3D10_BUFFER_SRV + + + + The offset of the first element in the view to access, relative to element 0. + + int FirstElement + + + + The total number of elements in the view. + + int ElementOffset + + + + No documentation. + + int NumElements + + + + No documentation. + + int ElementWidth + + + + Specifies the {{subresource}} from a {{1D texture}} to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). + + D3D10_TEX1D_SRV + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels -1. + + int MostDetailedMip + + + + Number of mipmap levels to use. + + int MipLevels + + + + Specifies the {{subresource(s)}} from an array of {{1D textures}} to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). + + D3D10_TEX1D_ARRAY_SRV + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels -1. + + int MostDetailedMip + + + + Number of subtextures to access. + + int MipLevels + + + + The index of the first texture to use in an array of textures (see {{array slice}}) + + int FirstArraySlice + + + + Number of textures in the array. + + int ArraySize + + + + Specifies the {{subresource}} from a {{2D texture}} to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). + + D3D10_TEX2D_SRV + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels -1. + + int MostDetailedMip + + + + Number of mipmap levels to use. + + int MipLevels + + + + Specifies the {{subresource(s)}} from an array of {{2D textures}} to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). + + D3D10_TEX2D_ARRAY_SRV + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels -1. + + int MostDetailedMip + + + + Number of subtextures to access. + + int MipLevels + + + + The index of the first texture to use in an array of textures (see {{array slice}}) + + int FirstArraySlice + + + + Number of textures in the array. + + int ArraySize + + + + Specifies the {{subresource(s)}} from a {{3D texture}} to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). + + D3D10_TEX3D_SRV + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels -1. + + int MostDetailedMip + + + + Number of mipmap levels to use. + + int MipLevels + + + + Specifies the {{subresource}} from a {{cube texture}} to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). + + D3D10_TEXCUBE_SRV + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels -1. + + int MostDetailedMip + + + + Number of mipmap levels to use. + + int MipLevels + + + + Specifies the {{subresource(s)}} from a multisampled {{2D texture}} to use in a shader-resource view. + + + Since a multisampled 2D texture contains a single subresource, there is actually nothing to specify in . Consequently, UnusedField_NothingToDefine is included so that this structure will compile in C. + + D3D10_TEX2DMS_SRV + + + + Integer of any value. See remarks. + + int UnusedField_NothingToDefine + + + + Specifies the {{subresource(s)}} from an array of multisampled {{2D textures}} to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). + + D3D10_TEX2DMS_ARRAY_SRV + + + + The index of the first texture to use in an array of textures (see {{array slice}}) + + int FirstArraySlice + + + + Number of textures to use. + + int ArraySize + + + + Specifies the {{subresource(s)}} from a resource that are accessible using a render-target view. + + + A render-target-view description is passed into to create a render target. A render-target-view cannot use the following formats: Any {{typeless format}}. if the view will be used to bind a buffer (vertex, index, constant, or stream-output). If the format is set to , then the format of the resource that the view binds to the pipeline will be used. + + D3D10_RENDER_TARGET_VIEW_DESC + + + + The data format (see ). + + DXGI_FORMAT Format + + + + The resource type (see ), which specifies how the render-target resource will be accessed. + + D3D10_RTV_DIMENSION ViewDimension + + + + Specifies which buffer elements can be accessed (see ). + + D3D10_BUFFER_RTV Buffer + + + + Specifies the subresources in a 1D texture that can be accessed (see ). + + D3D10_TEX1D_RTV Texture1D + + + + Specifies the subresources in a 1D texture array that can be accessed (see ). + + D3D10_TEX1D_ARRAY_RTV Texture1DArray + + + + Specifies the subresources in a 2D texture that can be accessed (see ). + + D3D10_TEX2D_RTV Texture2D + + + + Specifies the subresources in a 2D texture array that can be accessed (see ). + + D3D10_TEX2D_ARRAY_RTV Texture2DArray + + + + Specifies a single subresource because a multisampled 2D texture only contains one subresource (see ). + + D3D10_TEX2DMS_RTV Texture2DMS + + + + Specifies the subresources in a multisampled 2D texture array that can be accessed (see ). + + D3D10_TEX2DMS_ARRAY_RTV Texture2DMSArray + + + + Specifies subresources in a 3D texture that can be accessed (see ). + + D3D10_TEX3D_RTV Texture3D + + + + Specifies the elements from a {{buffer}} resource to use in a render-target view. + + + A render-target view is a member of a render-target-view description (see ). Create a render-target view by calling . + + D3D10_BUFFER_RTV + + + + The offset (that is, the number of elements) between the beginning of the buffer and the first element that is to be used in the view, starting at 0. + + int FirstElement + + + + The number of elements in the view. + + int ElementOffset + + + + No documentation. + + int NumElements + + + + No documentation. + + int ElementWidth + + + + Specifies the {{subresource}} from a {{1D texture}} to use in a render-target view. + + + This structure is one member of a render-target-view description (see ). + + D3D10_TEX1D_RTV + + + + The index of the mipmap level to use (see {{mip slice}}). + + int MipSlice + + + + Specifies the {{subresource(s)}} from an array of {{1D textures}} to use in a render-target view. + + + This structure is one member of a render-target-view description (see ). + + D3D10_TEX1D_ARRAY_RTV + + + + The index of the mipmap level to use (see {{mip slice}}). + + int MipSlice + + + + The index of the first texture to use in an array of textures (see {{array slice}}) + + int FirstArraySlice + + + + Number of textures to use. + + int ArraySize + + + + Specifies the {{subresource}} from a {{2D texture}} to use in a render-target view. + + + This structure is one member of a render-target-view description (see ). + + D3D10_TEX2D_RTV + + + + The index of the mipmap level to use (see {{mip slice}}). + + int MipSlice + + + + Specifies the {{subresource}} from a multisampled {{2D texture}} to use in a render-target view. + + + Since a multisampled 2D texture contains a single subresource, there is actually nothing to specify in D3D10_TEX2DMS_RTV. Consequently, UnusedField_NothingToDefine is included so that this structure will compile in C. + + D3D10_TEX2DMS_RTV + + + + Integer of any value. See remarks. + + int UnusedField_NothingToDefine + + + + Specifies the {{subresource(s)}} from an array of {{2D textures}} to use in a render-target view. + + + This structure is one member of a render-target-view description (see ). + + D3D10_TEX2D_ARRAY_RTV + + + + The index of the mipmap level to use (see {{mip slice}}). + + int MipSlice + + + + The index of the first texture to use in an array of textures (see {{array slice}}) + + int FirstArraySlice + + + + Number of textures in the array to use in the render target view, starting from FirstArraySlice. + + int ArraySize + + + + Specifies the {{subresource(s)}} from a an array of multisampled {{2D textures}} to use in a render-target view. + + + This structure is one member of a render-target-view description (see ). + + D3D10_TEX2DMS_ARRAY_RTV + + + + The index of the first texture to use in an array of textures (see {{array slice}}) + + int FirstArraySlice + + + + Number of textures to use. + + int ArraySize + + + + Specifies the {{subresource(s)}} from a {{3D texture}} to use in a render-target view. + + + This structure is one member of a render target view. See . + + D3D10_TEX3D_RTV + + + + The index of the mipmap level to use (see {{mip slice}}). + + int MipSlice + + + + First depth level to use. + + int FirstWSlice + + + + Number of depth levels to use in the render-target view, starting from FirstWSlice. A value of -1 indicates all of the slices along the w axis, starting from FirstWSlice. + + int WSize + + + + Specifies the {{subresource(s)}} from a texture that are accessible using a depth-stencil view. + + + These are valid formats for a depth-stencil view: DXGI_FORMAT_D16_UNORM DXGI_FORMAT_D24_UNORM_S8_UINT DXGI_FORMAT_D32_FLOAT DXGI_FORMAT_D32_FLOAT_S8X24_UINT DXGI_FORMAT_UNKNOWN A depth-stencil view cannot use a {{typeless format}}. If the format chosen is DXGI_FORMAT_UNKNOWN, then the format of the parent resource is used. A depth-stencil-view description is needed when calling . + + D3D10_DEPTH_STENCIL_VIEW_DESC + + + + Resource data format (see ). See remarks for allowable formats. + + DXGI_FORMAT Format + + + + Type of resource (see ). Specifies how a depth-stencil resource will be accessed; the value is stored in the union in this structure. + + D3D10_DSV_DIMENSION ViewDimension + + + + Specifies a 1D texture subresource (see ). + + D3D10_TEX1D_DSV Texture1D + + + + Specifies an array of 1D texture subresources (see ). + + D3D10_TEX1D_ARRAY_DSV Texture1DArray + + + + Specifies a 2D texture subresource (see ). + + D3D10_TEX2D_DSV Texture2D + + + + Specifies an array of 2D texture subresources (see ). + + D3D10_TEX2D_ARRAY_DSV Texture2DArray + + + + Specifies a multisampled 2D texture contains a single subresource (see ). + + D3D10_TEX2DMS_DSV Texture2DMS + + + + Specifies a multisampled 2D texture contains a single subresource per texture (see ). + + D3D10_TEX2DMS_ARRAY_DSV Texture2DMSArray + + + + Specifies the {{subresource}} from a {{1D texture}} that is accessible to a depth-stencil view. + + + This structure is one member of a depth-stencil-view description (see ). + + D3D10_TEX1D_DSV + + + + The index of the first mipmap level to use (see {{mip slice}}). + + int MipSlice + + + + Specifies the {{subresource(s)}} from an array of {{1D textures}} to use in a depth-stencil view. + + + This structure is one member of a depth-stencil-view description (see ). + + D3D10_TEX1D_ARRAY_DSV + + + + The index of the first mipmap level to use (see {{mip slice}}). + + int MipSlice + + + + The index of the first texture to use in an array of textures (see {{array slice}}) + + int FirstArraySlice + + + + Number of textures to use. + + int ArraySize + + + + Specifies the {{subresource}} from a {{2D texture}} that is accessible to a depth-stencil view. + + + This structure is one member of a depth-stencil-view description (see ). + + D3D10_TEX2D_DSV + + + + The index of the first mipmap level to use (see {{mip slice}}). + + int MipSlice + + + + Specifies the {{subresource(s)}} from an array {{2D textures}} that are accessible to a depth-stencil view. + + + This structure is one member of a depth-stencil-view description (see ). + + D3D10_TEX2D_ARRAY_DSV + + + + The index of the first mipmap level to use (see {{mip slice}}). + + int MipSlice + + + + The index of the first texture to use in an array of textures (see {{array slice}}) + + int FirstArraySlice + + + + Number of textures to use. + + int ArraySize + + + + Specifies the {{subresource}} from a multisampled {{2D texture}} that is accessible to a depth-stencil view. + + + Since a multisampled 2D texture contains a single subtexture, there is nothing to specify; this unused member is included so that this structure will compile in C. + + D3D10_TEX2DMS_DSV + + + + Unused. + + int UnusedField_NothingToDefine + + + + Specifies the {{subresource(s)}} from an array of multisampled {{2D textures}} for a depth-stencil view. + + + This structure is one member of a depth-stencil-view description (see ). + + D3D10_TEX2DMS_ARRAY_DSV + + + + The index of the first texture to use in an array of textures (see {{array slice}}) + + int FirstArraySlice + + + + Number of textures to use. + + int ArraySize + + + + Describes a sampler state. + + + These are the default values for sampler state. StateDefault Value FilterMin_Mag_Mip_Point AddressUClamp AddressVClamp AddressWClamp MinLOD0.0f MaxLOD3.402823466e+38F (FLT_MAX) MipMapLODBias0.0f MaxAnisotropy16 ComparisonFuncNever BorderColorfloat4(0.0f, 0.0f, 0.0f, 0.0f) TextureN/A ? + + D3D10_SAMPLER_DESC + + + + Filtering method to use when sampling a texture (see ). + + D3D10_FILTER Filter + + + + Method to use for resolving a u texture coordinate that is outside the 0 to 1 range (see ). + + D3D10_TEXTURE_ADDRESS_MODE AddressU + + + + Method to use for resolving a v texture coordinate that is outside the 0 to 1 range. + + D3D10_TEXTURE_ADDRESS_MODE AddressV + + + + Method to use for resolving a w texture coordinate that is outside the 0 to 1 range. + + D3D10_TEXTURE_ADDRESS_MODE AddressW + + + + Offset from the calculated mipmap level. For example, if Direct3D calculates that a texture should be sampled at mipmap level 3 and MipLODBias is 2, then the texture will be sampled at mipmap level 5. + + float MipLODBias + + + + Clamping value used if D3D10_FILTER_ANISOTROPIC or D3D10_FILTER_COMPARISON_ANISOTROPIC is specified in Filter. Valid values are between 1 and 16. + + int MaxAnisotropy + + + + A function that compares sampled data against existing sampled data. The function options are listed in . + + D3D10_COMPARISON_FUNC ComparisonFunc + + + + Border color to use if D3D10_TEXTURE_ADDRESS_BORDER is specified for AddressU, AddressV, or AddressW. Range must be between 0.0 and 1.0 inclusive. + + SHARPDX_COLOR4 BorderColor + + + + Lower end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed. + + float MinLOD + + + + Upper end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed. This value must be greater than or equal to MinLOD. To have no upper limit on LOD set this to a large value such as D3D10_FLOAT32_MAX. + + float MaxLOD + + + + Describes a query. + + D3D10_QUERY_DESC + + + + Type of query (see ). + + D3D10_QUERY Query + + + + Miscellaneous flags (see ). + + D3D10_QUERY_MISC_FLAG MiscFlags + + + + Query information about the reliability of a timestamp query. + + + For a list of query types see . + + D3D10_QUERY_DATA_TIMESTAMP_DISJOINT + + + + How frequently the GPU counter increments in Hz. + + __int64 Frequency + + + + If this is TRUE, something occurred in between the query's and calls that caused the timestamp counter to become discontinuous or disjoint, such as unplugging the AC chord on a laptop, overheating, or throttling up/down due to laptop savings events. The timestamp returned by for a timestamp query is only reliable if Disjoint is FALSE. + + BOOL Disjoint + + + + Query information about graphics-pipeline activity in between calls to and . + + D3D10_QUERY_DATA_PIPELINE_STATISTICS + + + + Number of vertices read by input assembler. + + __int64 IAVertices + + + + Number of primitives read by the input assembler. This number can be different depending on the primitive topology used. For example, a triangle strip with 6 vertices will produce 4 triangles, however a triangle list with 6 vertices will produce 2 triangles. + + __int64 IAPrimitives + + + + Number of times a vertex shader was invoked. Direct3D invokes the vertex shader once per vertex. + + __int64 VSInvocations + + + + Number of times a geometry shader was invoked. When the geometry shader is set to NULL, this statistic may or may not increment depending on the hardware manufacturer. + + __int64 GSInvocations + + + + Number of primitives output by a geometry shader. + + __int64 GSPrimitives + + + + Number of primitives that were sent to the rasterizer. When the rasterizer is disabled, this will not increment. + + __int64 CInvocations + + + + Number of primitives that were rendered. This may be larger or smaller than CInvocations because after a primitive is clipped sometimes it is either broken up into more than one primitive or completely culled. + + __int64 CPrimitives + + + + Number of times a pixel shader was invoked. + + __int64 PSInvocations + + + + Query information about the amount of data streamed out to the stream-output buffers in between and . + + D3D10_QUERY_DATA_SO_STATISTICS + + + + Number of primitives (that is, points, lines, and triangles) written to the stream-output buffers. + + __int64 NumPrimitivesWritten + + + + Number of primitives that would have been written to the stream-output buffers if there had been enough space for them all. + + __int64 PrimitivesStorageNeeded + + + + Describes a counter. + + D3D10_COUNTER_DESC + + + + Type of counter (see ). + + D3D10_COUNTER Counter + + + + Reserved. + + int MiscFlags + + + + Information about the video card's performance counter capabilities. + + + This structure is returned by . + + D3D10_COUNTER_INFO + + + + Largest device-dependent counter ID that the device supports. If none are supported, this value will be 0. Otherwise it will be greater than or equal to D3D10_COUNTER_DEVICE_DEPENDENT_0. See . + + D3D10_COUNTER LastDeviceDependentCounter + + + + Number of counters that can be simultaneously supported. + + int NumSimultaneousCounters + + + + Number of detectable parallel units that the counter is able to discern. Values are 1 ~ 4. Use NumDetectableParallelUnits to interpret the values of the VERTEX_PROCESSING, GEOMETRY_PROCESSING, PIXEL_PROCESSING, and OTHER_GPU_PROCESSING counters. See for an equation. + + byte NumDetectableParallelUnits + + + + Describes a shader constant-buffer. + + + Constants are supplied to shaders in a shader-constant buffer. Get the description of a shader-constant-buffer by calling {{ID3D10ShaderReflectionConstantBuffer::GetDesc}}. + + D3D10_SHADER_BUFFER_DESC + + + + The name of the buffer. + + const char* Name + + + + The intended use of the constant data. See . + + D3D10_CBUFFER_TYPE Type + + + + The number of unique variables. + + int Variables + + + + Buffer size (in bytes). + + int Size + + + + Shader buffer properties. See . + + D3D_SHADER_CBUFFER_FLAGS uFlags + + + + Describes a shader signature. + + + A shader can take n inputs and can produce m outputs. The order of the input (or output) parameters, their associated types, and any attached semantics make up the shader signature. Each shader has an input and an output signature. When compiling a shader or an effect, some API calls validate shader signatures (such as {{D3D10CompileShader}} and {{D3D10CompileEffectFromMemory}}). That is, they compare the output signature of one shader (like a vertex shader) with the input signature of another shader (like a pixel shader). This ensures that a shader outputs data that is compatible with a downstream shader that is consuming that data. Compatible means that a shader signature is a exact-match subset of the preceding shader stage. Exact match means parameter types and semantics must exactly match. Subset means that a parameter that is not required by a downstream stage, does not need to include that parameter in its shader signature. Get a shader-signature from a shader or an effect by calling APIs such as {{ID3D10ShaderReflection::GetInputParameterDesc}} or . + + D3D10_SIGNATURE_PARAMETER_DESC + + + + A per-parameter string that identifies how the data will be used. See {{Semantics (DirectX HLSL)}}. + + const char* SemanticName + + + + Semantic index that modifies the semantic. Used to differentiate different parameters that use the same semantic. + + int SemanticIndex + + + + The register that will contain this variable's data. + + int Register + + + + A predefined string that determines the functionality of certain pipeline stages. See . + + D3D10_NAME SystemValueType + + + + The per-component-data type that is stored in a register. See . Each register can store up to four-components of data. + + D3D10_REGISTER_COMPONENT_TYPE ComponentType + + + + Mask which indicates which components of a register are used. + + byte Mask + + + + Mask which indicates whether a given component is never written (if the signature is an output signature) or always read (if the signature is an input signature). The mask is a combination of values. + + byte ReadWriteMask + + + + Indicates the device state. + + + A state-block mask indicates the device states that a pass or a technique changes. The function provides a convenient way of setting a range of bitmasks for the array members of D3D10_STATE_BLOCK_MASK. + + D3D10_STATE_BLOCK_MASK + + + + Boolean value indicating whether to save the vertex shader state. + + bool VS + + + + Boolean value indicating whether to save the geometry shader state. + + bool GS + + + + Boolean value indicating whether to save the pixel shader state. + + bool PS + + + + Boolean value indicating whether to save the index buffer state. + + bool IAIndexBuffer + + + + Boolean value indicating whether to save the input layout state. + + bool IAInputLayout + + + + Boolean value indicating whether to save the primitive topology state. + + bool IAPrimitiveTopology + + + + Boolean value indicating whether to save the render targets states. + + bool OMRenderTargets + + + + Boolean value indicating whether to save the depth-stencil state. + + bool OMDepthStencilState + + + + Boolean value indicating whether to save the blend state. + + bool OMBlendState + + + + Boolean value indicating whether to save the viewports states. + + bool RSViewports + + + + Boolean value indicating whether to save the scissor rectangles states. + + bool RSScissorRects + + + + Boolean value indicating whether to save the rasterizer state. + + bool RSRasterizerState + + + + Boolean value indicating whether to save the stream-out buffers states. + + bool SOBuffers + + + + Boolean value indicating whether to save the predication state. + + bool Predication + + + + Array of vertex-shader samplers. The array is a multi-byte bitmask where each bit represents one sampler slot. + + bool VSSamplers[2.875] + + + + Array of vertex-shader resources. The array is a multi-byte bitmask where each bit represents one resource slot. + + bool VSShaderResources[16.875] + + + + Array of vertex-shader constant buffers. The array is a multi-byte bitmask where each bit represents one constant buffer slot. + + bool VSConstantBuffers[2.625] + + + + Array of geometry-shader samplers. The array is a multi-byte bitmask where each bit represents one sampler slot. + + bool GSSamplers[2.875] + + + + Array of geometry-shader resources. The array is a multi-byte bitmask where each bit represents one resource slot. + + bool GSShaderResources[16.875] + + + + Array of geometry-shader constant buffers. The array is a multi-byte bitmask where each bit represents one buffer slot. + + bool GSConstantBuffers[2.625] + + + + Array of pixel-shader samplers. The array is a multi-byte bitmask where each bit represents one sampler slot. + + bool PSSamplers[2.875] + + + + Array of pixel-shader resources. The array is a multi-byte bitmask where each bit represents one resource slot. + + bool PSShaderResources[16.875] + + + + Array of pixel-shader constant buffers. The array is a multi-byte bitmask where each bit represents one constant buffer slot. + + bool PSConstantBuffers[2.625] + + + + Array of vertex buffers. The array is a multi-byte bitmask where each bit represents one resource slot. + + bool IAVertexBuffers[2.875] + + + + Describes an effect-variable type. + + + To get an effect-variable type, call . + + D3D10_EFFECT_TYPE_DESC + + + + A string that contains the variable name. + + const char* TypeName + + + + The variable class (see ). + + D3D10_SHADER_VARIABLE_CLASS Class + + + + The variable type (see ). + + D3D10_SHADER_VARIABLE_TYPE Type + + + + The number of elements if the variable is an array; otherwise 0. + + int Elements + + + + The number of members if the variable is a structure; otherwise 0. + + int Members + + + + The number of rows if the variable is a matrix; otherwise 0. + + int Rows + + + + The number of columns if the variable is a matrix; otherwise 0. + + int Columns + + + + The number of bytes that the variable consumes when it is packed tightly by the compiler. + + int PackedSize + + + + The number of bytes that the variable consumes before it is packed by the compiler. + + int UnpackedSize + + + + The number of bytes between elements. + + int Stride + + + + Describes an effect variable. + + + To get an effect-variable description, call . + + D3D10_EFFECT_VARIABLE_DESC + + + + A string that contains the variable name. + + const char* Name + + + + The semantic attached to the variable; otherwise NULL. + + const char* Semantic + + + + Optional {{flags}} for effect variables. + + D3D10_EFFECT_VARIABLE_FLAGS Flags + + + + The number of annotations; otherwise 0. + + int Annotations + + + + The offset between the begining of the constant buffer and this variable; otherwise 0. + + int BufferOffset + + + + The register that this variable is bound to. To bind a variable explicitly use the D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT flag. + + int ExplicitBindPoint + + + + Describes an effect technique. + + + To get a technique, call . + + D3D10_TECHNIQUE_DESC + + + + A string that contains the technique name; otherwise NULL. + + const char* Name + + + + The number of passes in the technique. + + int Passes + + + + The number of annotations. + + int Annotations + + + + Describes an effect. + + + To get an effect description, call . + + D3D10_EFFECT_DESC + + + + The number of constant buffers. + + int ConstantBuffers + + + + The number of constant buffers shared in an effect pool. + + int SharedConstantBuffers + + + + The number of global variables. + + int GlobalVariables + + + + The number of global variables shared in an effect pool. + + int SharedGlobalVariables + + + + The number of techniques. + + int Techniques + + + + TRUE if the effect is a {{child effect}}; otherwise FALSE. + + BOOL IsChildEffect + + + + Describes the blend state for a render target for a Direct3D 10.1 device + + + To see how blending is done, see {{Output-Merger Stage (Direct3D 10)}}. These are the default values for blend state. StateDefault Value BlendEnableFALSE SrcBlendD3D10_BLEND_ONE DestBlendD3D10_BLEND_ZERO BlendOpD3D10_BLEND_OP_ADD SrcBlendAlphaD3D10_BLEND_ONE DestBlendAlphaD3D10_BLEND_ZERO BlendOpAlphaD3D10_BLEND_OP_ADD RenderTargetWriteMask0xFF ? + + D3D10_RENDER_TARGET_BLEND_DESC1 + + + + This {{blend option}} specifies the first RGB data source and includes an optional pre-blend operation. + + D3D10_BLEND SrcBlend + + + + This {{blend option}} specifies the second RGB data source and includes an optional pre-blend operation. + + D3D10_BLEND DestBlend + + + + This {{blend operation}} defines how to combine the RGB data sources. + + D3D10_BLEND_OP BlendOp + + + + This {{blend option}} specifies the first alpha data source and includes an optional pre-blend operation. Blend options that end in _COLOR are not allowed. + + D3D10_BLEND SrcBlendAlpha + + + + This {{blend option}} specifies the second alpha data source and includes an optional pre-blend operation. Blend options that end in _COLOR are not allowed. + + D3D10_BLEND DestBlendAlpha + + + + This {{blend operation}} defines how to combine the alpha data sources. + + D3D10_BLEND_OP BlendOpAlpha + + + + A write mask. + + D3D10_COLOR_WRITE_ENABLE RenderTargetWriteMask + + + + Enable (or disable) blending. + + BOOL BlendEnable + + + + Describes the blend state for a Direct3D 10.1 device. + + + To see how blending is done, see {{Output-Merger Stage (Direct3D 10)}}. These are the default values for the blend description. StateDefault Value AlphaToCoverageEnableFALSE IndependentBlendEnableFALSE RenderTarget[0].BlendEnableFALSE RenderTarget[0].SrcBlendD3D10_BLEND_ONE RenderTarget[0].DestBlendD3D10_BLEND_ZERO RenderTarget[0].BlendOpD3D10_BLEND_OP_ADD RenderTarget[0].SrcBlendAlphaD3D10_BLEND_ONE RenderTarget[0].DestBlendAlphaD3D10_BLEND_ZERO RenderTarget[0].BlendOpAlphaD3D10_BLEND_OP_ADD RenderTarget[0].RenderTargetWriteMaskD3D10_COLOR_WRITE_ENABLE_ALL ? This structure requires Windows Vista Service Pack 1. If the driver type is set to , the feature level is set to less than or equal to , and the pixel format of the render target is set to , DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, or DXGI_FORMAT_B8G8R8X8_UNORM_SRGB, the device performs the blend in standard RGB (sRGB) space and not in linear space. However, if the feature level is set to greater than D3D_FEATURE_LEVEL_9_3, the device performs the blend in linear space. + + D3D10_BLEND_DESC1 + + + + Determines whether or not to use the {{alpha-to-coverage}} multisampling technique when setting a render-target pixel. + + BOOL AlphaToCoverageEnable + + + + Set to TRUE to enable independent blending in simultaneous render targets. If set to FALSE, only the RenderTarget[0] members are used. RenderTarget[1..7] are ignored. + + BOOL IndependentBlendEnable + + + + An array of render-target-blend descriptions (see ); these correspond to the eight rendertargets that can be set to the output-merger stage at one time. + + D3D10_RENDER_TARGET_BLEND_DESC1 RenderTarget[8] + + + + Describes a shader-resource view. + + + A view is a format-specific way to look at the data in a resource. The view determines what data to look at, and how it is cast when read. For more information about how views work, see {{Views}} When viewing a resource, the resource-view description must specify a typed format, that is compatible with the resource format. So that means that you cannot create a resource-view description using any format with _TYPELESS in the name. You can however view a typeless resource by specifying a typed format for the view. For example, a DXGI_FORMAT_R32G32B32_TYPELESS resource can be viewed with one of these typed formats: DXGI_FORMAT_R32G32B32_FLOAT, DXGI_FORMAT_R32G32B32_UINT, and DXGI_FORMAT_R32G32B32_SINT, since these typed formats are compatible with the typeless resource. Create a shader-resource-view description by calling . To view a shader-resource-view description, call . This structure requires Windows Vista Service Pack 1. + + D3D10_SHADER_RESOURCE_VIEW_DESC1 + + + + The viewing {{format}}. See remarks. + + DXGI_FORMAT Format + + + + The resource type of the view. See . This should be the same as the resource type of the underlying resource. This parameter also determines which _SRV to use in the union below. + + D3D10_SRV_DIMENSION1 ViewDimension + + + + View the resource as a buffer using information from a shader-resource view (see ). + + D3D10_BUFFER_SRV Buffer + + + + View the resource as a 1D texture using information from a shader-resource view (see ). + + D3D10_TEX1D_SRV Texture1D + + + + View the resource as a 1D-texture array using information from a shader-resource view (see . + + D3D10_TEX1D_ARRAY_SRV Texture1DArray + + + + View the resource as a 2D-texture using information from a shader-resource view (see . + + D3D10_TEX2D_SRV Texture2D + + + + View the resource as a 2D-texture array using information from a shader-resource view (see . + + D3D10_TEX2D_ARRAY_SRV Texture2DArray + + + + View the resource as a 2D-multisampled texture using information from a shader-resource view (see . + + D3D10_TEX2DMS_SRV Texture2DMS + + + + View the resource as a 2D-multisampled-texture array using information from a shader-resource view (see . + + D3D10_TEX2DMS_ARRAY_SRV Texture2DMSArray + + + + View the resource as a 3D texture using information from a shader-resource view (see . + + D3D10_TEX3D_SRV Texture3D + + + + View the resource as a 3D-cube texture using information from a shader-resource view (see ). + + D3D10_TEXCUBE_SRV TextureCube + + + + View the resource as an array of cube textures using information from a shader-resource view (see ). + + D3D10_TEXCUBE_ARRAY_SRV1 TextureCubeArray + + + + Specifies the {{subresource(s)}} from an array of {{cube textures}} to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). This structure requires Windows Vista Service Pack 1. + + D3D10_TEXCUBE_ARRAY_SRV1 + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels. + + int MostDetailedMip + + + + Number of mipmap levels to use. + + int MipLevels + + + + Index of the first 2D texture to use. + + int First2DArrayFace + + + + Number of cube textures in the array. + + int NumCubes + + + + Defines position, texture, and color information about a sprite. + + D3DX10_SPRITE + + + + The sprite's model-world transformation. This defines the position and orientation of the sprite in world space. + + D3DXMATRIX matWorld + + + + Offset from the upper-left corner of the texture indicating where the sprite image should start in the texture. TexCoord is in texture coordinates. + + D3DXVECTOR2 TexCoord + + + + A vector containing the width and height of the sprite in texture coordinates. + + D3DXVECTOR2 TexSize + + + + A color that will be multiplied with the pixel color before rendering. + + D3DXCOLOR ColorModulate + + + + Pointer to a shader-resource view representing the sprite's texture. See . + + ID3D10ShaderResourceView* pTexture + + + + The index of the texture. If pTexture does not represent a texture array, then this should be 0. + + int TextureIndex + + + + Gets or sets the texture. + + The texture. + + + + No documentation. + + D3DX10_FONT_DESCW + + + + No documentation. + + int Height + + + + No documentation. + + int Width + + + + No documentation. + + D3DX10_FONT_WEIGHT Weight + + + + No documentation. + + int MipLevels + + + + No documentation. + + D3DX10_FONT_CHARSET CharSet + + + + No documentation. + + D3DX10_FONT_PRECISION OutputPrecision + + + + No documentation. + + D3DX10_FONT_QUALITY Quality + + + + No documentation. + + D3DX10_FONT_PITCHFAMILY PitchAndFamily + + + + No documentation. + + wchar_t FaceName[32] + + + + No documentation. + + BOOL Italic + + + + Returns a description of the original contents of an image file. + + D3DX10_IMAGE_INFO + + + + Width of original image in pixels. + + int Width + + + + Height of original image in pixels. + + int Height + + + + Depth of original image in pixels. + + int Depth + + + + Size of the texture array. ArraySize will be 1 for a single image. + + int ArraySize + + + + Number of mipmap levels in original image. + + int MipLevels + + + + Miscellaneous resource properties (see ). + + D3D10_RESOURCE_MISC_FLAG MiscFlags + + + + A value from the enumerated type that most closely describes the data in the original image. + + DXGI_FORMAT Format + + + + Represents the type of the texture stored in the file. See . + + D3D10_RESOURCE_DIMENSION ResourceDimension + + + + Represents the format of the image file. See . + + D3DX10_IMAGE_FILE_FORMAT ImageFileFormat + + + + Retrieves information about a given image file. + + File name of image to retrieve information about. + If the function succeeds, returns a filled with the description of the data in the source file. else returns null + HRESULT D3DX11GetImageInfoFromFileW([None] const wchar_t* pSrcFile,[None] ID3DX11ThreadPump* pPump,[None] D3DX11_IMAGE_INFO* pSrcInfo,[None] HRESULT* pHResult) + + + + Retrieves information about a given image file from a memory location. + + an array to the image in memory + If the function succeeds, returns a filled with the description of the data from the image memory. else returns null + HRESULT D3DX11GetImageInfoFromFileW([None] const wchar_t* pSrcFile,[None] ID3DX11ThreadPump* pPump,[None] D3DX11_IMAGE_INFO* pSrcInfo,[None] HRESULT* pHResult) + + + + Optionally provide information to texture loader APIs to control how textures get loaded. A value of D3DX10_DEFAULT for any of these parameters will cause D3DX to automatically use the value from the source file. + + + When initializing the structure, you may set any member to D3DX10_DEFAULT and D3DX will initialize it with a default value from the source texture when the texture is loaded. This structure can be used by APIs that: Create resources, such as {{D3DX10CreateTextureFromFile}} and {{D3DX10CreateShaderResourceViewFromFile}}. Create data processors, such as {{D3DX10CreateAsyncTextureInfoProcessor}} or + {{D3DX10CreateAsyncShaderResourceViewProcessor}}. + + D3DX10_IMAGE_LOAD_INFO + + + + The default value for load options. + + + + + The target width of the texture. If the actual width of the texture is larger or smaller than this value then the texture will be scaled up or down to fit this target width. + + int Width + + + + The target height of the texture. If the actual height of the texture is larger or smaller than this value then the texture will be scaled up or down to fit this target height. + + int Height + + + + The depth of the texture. This only applies to volume textures. + + int Depth + + + + The highest resolution mipmap level of the texture. If this is greater than 0, then after the texture is loaded FirstMipLevel will be mapped to mipmap level 0. + + int FirstMipLevel + + + + The maximum number of mipmap levels that the texture will have. Using 0 or D3DX10_DEFAULT will cause a full mipmap chain to be created. + + int MipLevels + + + + The way the texture resource is intended to be used. See . + + D3D10_USAGE Usage + + + + The pipeline stages that the texture will be allowed to bind to. See . + + D3D10_BIND_FLAG BindFlags + + + + The access permissions the cpu will have for the texture resource. See . + + D3D10_CPU_ACCESS_FLAG CpuAccessFlags + + + + Miscellaneous resource properties (see ). + + D3D10_RESOURCE_MISC_FLAG MiscFlags + + + + The format the texture will be in after it is loaded. See . + + DXGI_FORMAT Format + + + + Filter the texture using the specified filter (only when resampling). See . + + D3DX10_FILTER_FLAG Filter + + + + Filter the texture mip levels using the specified filter (only if generating mipmaps). Valid values are D3DX10_FILTER_NONE, D3DX10_FILTER_POINT, D3DX10_FILTER_LINEAR, or D3DX10_FILTER_TRIANGLE. See . + + D3DX10_FILTER_FLAG MipFilter + + + + Information about the original image. See . Can be obtained with {{D3DX10GetImageInfoFromFile}}, , or {{D3DX10GetImageInfoFromResource}}. + + D3DX10_IMAGE_INFO* pSrcInfo + + + + Describes parameters used to load a texture from another texture. + + + This structure is used in a call to . + + D3DX10_TEXTURE_LOAD_INFO + + + + Source texture box (see ). + + D3D10_BOX* pSrcBox + + + + Destination texture box (see ). + + D3D10_BOX* pDstBox + + + + Source texture mipmap level, see {{D3D10CalcSubresource}} for more detail. + + int SrcFirstMip + + + + Destination texture mipmap level, see {{D3D10CalcSubresource}} for more detail. + + int DstFirstMip + + + + Number of mipmap levels in the source texture. + + int NumMips + + + + First element of the source texture. + + int SrcFirstElement + + + + First element of the destination texture. + + int DstFirstElement + + + + Number of elements to load. + + int NumElements + + + + Filtering options during resampling (see ). + + D3DX10_FILTER_FLAG Filter + + + + Filtering options when generating mip levels (see ). + + D3DX10_FILTER_FLAG MipFilter + + + + Source texture box (see ). + + D3D11_BOX* pSrcBox + + + + Destination texture box (see ). + + D3D11_BOX* pDstBox + + + + Stores an attribute table entry. + + + An attribute table is used to identify areas of the mesh that need to be drawn with different textures, render states, materials, and so on. In addition, the application can use the attribute table to hide portions of a mesh by not drawing a given attribute identifier (AttribId) when drawing the frame. The LPD3DX_ATTRIBUTE_RANGE type is defined as a reference to the D3DX_ATTRIBUTE_RANGE structure. + typedef D3DX_ATTRIBUTE_RANGE* LPD3DX_ATTRIBUTE_RANGE; + + + + D3DX10_ATTRIBUTE_RANGE + + + + Attribute table identifier. + + int AttribId + + + + Starting face. + + int FaceStart + + + + Face count. + + int FaceCount + + + + Starting vertex. + + int VertexStart + + + + Vertex count. + + int VertexCount + + + + The member of the vertex decl to do the software skinning on. This is used with the API. + + D3DX10_SKINNING_CHANNEL + + + + Offset from the beginning of each source vertex. + + int SrcOffset + + + + Offset from the beginning of each destination vertex. + + int DestOffset + + + + Determines which array of matrices to use in the API. If this is true, the pInverseTransposeBoneMatrices will be used, otherwise pBoneMatrices will be used. + + BOOL IsNormal + + + + Specifies mesh weight attributes. + + + This structure describes how a simplification operation will consider vertex data when calculating relative costs between collapsing edges. For example, if the Normal field is 0.0, the simplification operation will ignore the vertex normal component when calculating the error for the collapse. However, if the Normal field is 1.0, the simplification operation will use the vertex normal component. If the Normal field is 2.0, double the amount of errors; if the Normal field is 4.0, then quadruple the number of errors, and so on. The LPD3DX_ATTRIBUTE_WEIGHTS type is defined as a reference to the D3DX_ATTRIBUTE_WEIGHTS structure. + typedef D3DX_ATTRIBUTE_WEIGHTS* LPD3DX_ATTRIBUTE_WEIGHTS; + + + + D3DX10_ATTRIBUTE_WEIGHTS + + + + Position. + + float Position + + + + Blend weight. + + float Boundary + + + + Normal. + + float Normal + + + + Diffuse lighting value. + + float Diffuse + + + + Specular lighting value. + + float Specular + + + + Tangent. + + float Tangent + + + + Binormal. + + float Binormal + + + + Eight texture coordinates. + + float Texcoord[8] + + + + Properties defining the way a buffer is bound to the pipeline as a target for stream output operations. + + + + + Initializes a new instance of the struct. + + The buffer being bound. + The offset to the first vertex (in bytes). + + + + Gets or sets the buffer being bound. + + + + + Gets or sets the offset from the start of the buffer of the first vertex to use (in bytes). + + + + + Properties defining the way a buffer (containing vertex data) is bound + to the pipeline for rendering. + + + + + Initializes a new instance of the struct. + + The buffer being bound. + The stride between vertex element (in bytes). + The offset to the first vertex (in bytes). + + + + Gets or sets the buffer being bound. + + + + + Gets or sets the stride between vertex elements in the buffer (in bytes). + + + + + Gets or sets the offset from the start of the buffer of the first vertex to use (in bytes). + + + + diff --git a/Libs/SharpDX.Direct3D11.dll b/Libs/SharpDX.Direct3D11.dll new file mode 100644 index 0000000000000000000000000000000000000000..e8bdc28c023250714040289ac08f2832fe5caaf1 GIT binary patch literal 146432 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 XG$!?D(|e* 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

|dYh+6m!2k!i5eH7<$@76@vkjwpujf!< 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 X=U+_%nwt|U^JWINfB*c;N#H*L3>7!O literal 0 HcmV?d00001 diff --git a/Libs/SharpDX.Direct3D11.xml b/Libs/SharpDX.Direct3D11.xml new file mode 100644 index 0000000..39c45e5 --- /dev/null +++ b/Libs/SharpDX.Direct3D11.xml @@ -0,0 +1,15004 @@ + + + + SharpDX.Direct3D11 + + + +

+ This blend-state interface accesses blending state for the output-merger stage. + + ID3D11BlendState + + + + A device-child interface accesses data used by a device. + + ID3D11DeviceChild + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a reference to the device that created this interface. + + + Any returned interfaces will have their reference count incremented by one, so be sure to call ::release() on the returned reference(s) before they are freed or else you will have a memory leak. + + Address of a reference to a device (see ). + void ID3D11DeviceChild::GetDevice([Out] ID3D11Device** ppDevice) + + + + Get application-defined data from a device child. + + + The data stored in the device child is set by calling . + + Guid associated with the data. + A reference to a variable that on input contains the size, in bytes, of the buffer that pData points to, and on output contains the size, in bytes, of the amount of data that GetPrivateData retrieved. + void A reference to a buffer that GetPrivateData fills with data from the device child if pDataSize points to a value that specifies a buffer large enough to hold the data. + This method returns one of the codes described in the topic {{Direct3D 11 Return Codes}}. + HRESULT ID3D11DeviceChild::GetPrivateData([In] GUID* guid,[InOut] int* pDataSize,[Out, Buffer, Optional] void* pData) + + + + Set application-defined data to a device child and associate that data with an application-defined guid. + + + The data stored in the device child with this method can be retrieved with . The {{debug layer}} reports memory leaks by outputting a list of object interface references along with their friendly names. The default friendly name is "<unnamed>". You can set the friendly name so that you can determine if the corresponding object interface reference caused the leak. To set the friendly name, use the SetPrivateData method and the WKPDID_D3DDebugObjectName GUID that is in D3Dcommon.h. For example, to give pContext a friendly name of My name, use the following code: + static const char c_szName[] = "My name"; + hr = pContext->SetPrivateData( WKPDID_D3DDebugObjectName, sizeof( c_szName ) - 1, c_szName ); + + + + Guid associated with the data. + Size of the data. + void Pointer to the data to be stored with this device child. If pData is NULL, DataSize must also be 0, and any data previously associated with the specified guid will be destroyed. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11DeviceChild::SetPrivateData([In] GUID* guid,[In] int DataSize,[In, Buffer, Optional] const void* pData) + + + + Associate an IUnknown-derived interface with this device child and associate that interface with an application-defined guid. + + + When this method is called ::addref() will be called on the IUnknown-derived interface, and when the device child is detroyed ::release() will be called on the IUnknown-derived interface. + + Guid associated with the interface. + IUnknown Pointer to an IUnknown-derived interface to be associated with the device child. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11DeviceChild::SetPrivateDataInterface([In] GUID* guid,[In, Optional] const IUnknown* pData) + + + + Get a reference to the device that created this interface. + + + Any returned interfaces will have their reference count incremented by one, so be sure to call ::release() on the returned reference(s) before they are freed or else you will have a memory leak. + + void ID3D11DeviceChild::GetDevice([Out] ID3D11Device** ppDevice) + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the blend state. + + A reference to the blend state (see ). + void ID3D11BlendState::GetDesc([Out] D3D11_BLEND_DESC* pDesc) + + + + Get the blend state. + + void ID3D11BlendState::GetDesc([Out] D3D11_BLEND_DESC* pDesc) + + + + A buffer interface accesses a buffer resource, which is unstructured memory. Buffers typically store vertex or index data. + + ID3D11Buffer + + + + A resource interface provides common actions on all resources. + + ID3D11Resource + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the type of the resource. + + Pointer to the resource type (see ). + void ID3D11Resource::GetType([Out] D3D11_RESOURCE_DIMENSION* pResourceDimension) + + + + Set the eviction priority of a resource. + + + Resource priorities determine which resource to evict from video memory when the system has run out of video memory. The resource will not be lost; it will be removed from video memory and placed into system memory, or possibly placed onto the hard drive. The resource will be loaded back into video memory when it is required. A resource that is set to the maximum priority, DXGI_RESOURCE_PRIORITY_MAXIMUM, is only evicted if there is no other way of resolving the incoming memory request. The Windows Display Driver Model (WDDM) tries to split an incoming memory request to its minimum size and evict lower-priority resources before evicting a resource with maximum priority. Changing the priorities of resources should be done carefully. The wrong eviction priorities could be a detriment to performance rather than an improvement. + + Eviction priority for the resource, which is one of the following values: DXGI_RESOURCE_PRIORITY_MINIMUM DXGI_RESOURCE_PRIORITY_LOW DXGI_RESOURCE_PRIORITY_NORMAL DXGI_RESOURCE_PRIORITY_HIGH DXGI_RESOURCE_PRIORITY_MAXIMUM + void ID3D11Resource::SetEvictionPriority([In] int EvictionPriority) + + + + Get the eviction priority of a resource. + + + + One of the following values, which specifies the eviction priority for the resource: DXGI_RESOURCE_PRIORITY_MINIMUM DXGI_RESOURCE_PRIORITY_LOW DXGI_RESOURCE_PRIORITY_NORMAL DXGI_RESOURCE_PRIORITY_HIGH DXGI_RESOURCE_PRIORITY_MAXIMUM + int ID3D11Resource::GetEvictionPriority() + + + + Gets a swap chain back buffer. + + The type of the buffer. + The swap chain to get the buffer from. + The index of the desired buffer. + The buffer interface, or null on failure. + + + + Loads a texture from an image file. + + The device used to load the texture. + Path to the file on disk. + The loaded texture object. + + + + Loads a texture from an image file. + + The device used to load the texture. + Path to the file on disk. + Specifies information used to load the texture. + The loaded texture object. + + + + Loads a texture from an image in memory. + + The device used to load the texture. + Array of memory containing the image data to load. + The loaded texture object. + + + + Loads a texture from an image in memory. + + The device used to load the texture. + Array of memory containing the image data to load. + Specifies information used to load the texture. + The loaded texture object. + + + + Loads a texture from a stream of data. + + The device used to load the texture. + A stream containing the image data to load. + Size of the image to load. + The loaded texture object. + + + + Loads a texture from a stream of data. + + The device used to load the texture. + A stream containing the image data to load. + Size of the image to load. + Specifies information used to load the texture. + The loaded texture object. + + + + Saves a texture to file. + + The device used to save the texture. + The texture to save. + The format the texture will be saved as. + Name of the destination output file where the texture will be saved. + A object describing the result of the operation. + + + + Saves a texture to a stream. + + The device used to save the texture. + The texture to save. + The format the texture will be saved as. + Destination memory stream where the image will be saved. + A object describing the result of the operation. + + + + Load a texture from a texture. + + A reference to a valid + Pointer to the source texture. See . + Pointer to the destination texture. See . + Pointer to texture loading parameters. See . + The return value is one of the values listed in {{Direct3D 10 Return Codes}}. + HRESULT D3DX10LoadTextureFromTexture([None] ID3D10Resource* pSrcTexture,[None] D3DX10_TEXTURE_LOAD_INFO* pLoadInfo,[None] ID3D10Resource* pDstTexture) + + + + Get the type of the resource. + + void ID3D11Resource::GetType([Out] D3D11_RESOURCE_DIMENSION* pResourceDimension) + + + + Get the eviction priority of a resource. + + + + int ID3D11Resource::GetEvictionPriority() + + + + Initializes a new instance of the class. + + The device with which to associate the buffer. + The description of the buffer. + + + + Initializes a new instance of the class. + + The device with which to associate the buffer. + Initial data used to initialize the buffer. + The description of the buffer. + + + + Initializes a new instance of the class. + + The device with which to associate the buffer. + The size, in bytes, of the buffer. + The usage pattern for the buffer. + Flags specifying how the buffer will be bound to the pipeline. + Flags specifying how the buffer will be accessible from the CPU. + Miscellaneous resource options. + The size (in bytes) of the structure element for structured buffers. + + + + Initializes a new instance of the class. + + The device with which to associate the buffer. + Initial data used to initialize the buffer. + The size, in bytes, of the buffer. + The usage pattern for the buffer. + Flags specifying how the buffer will be bound to the pipeline. + Flags specifying how the buffer will be accessible from the CPU. + Miscellaneous resource options. + The size (in bytes) of the structure element for structured buffers. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the properties of a buffer resource. + + Pointer to a resource description (see ) filled in by the method. + void ID3D11Buffer::GetDesc([Out] D3D11_BUFFER_DESC* pDesc) + + + + Get the properties of a buffer resource. + + void ID3D11Buffer::GetDesc([Out] D3D11_BUFFER_DESC* pDesc) + + + + Describes a buffer resource. + + + This structure is used by to create buffer resources. In addition to this structure, there is also a derived structure in D3D11.h (CD3D11_BUFFER_DESC) which behaves like an inherited class to help create a buffer description. If the bind flag is D3D11_BIND_CONSTANT_BUFFER then the ByteWidth value must be in multiples of 16, and less than or equal to D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT. + + D3D11_BUFFER_DESC + + + + Initializes a new instance of the struct. + + The size in bytes. + The usage. + The bind flags. + The cpu access flags. + The option flags. + The structure byte stride. + + + + Size of the buffer in bytes. + + int ByteWidth + + + + Identify how the buffer is expected to be read from and written to. Frequency of update is a key factor. The most common value is typically D3D11_USAGE_DEFAULT; see for all possible values. + + D3D11_USAGE Usage + + + + Identify how the buffer will be bound to the pipeline. Flags (see ) can be combined with a logical OR. + + D3D11_BIND_FLAG BindFlags + + + + CPU access flags (see ) or 0 if no CPU access is necessary. Flags can be combined with a logical OR. + + D3D11_CPU_ACCESS_FLAG CPUAccessFlags + + + + Miscellaneous flags (see ) or 0 if unused. Flags can be combined with a logical OR. + + D3D11_RESOURCE_MISC_FLAG MiscFlags + + + + The size of the structure (in bytes) when it represents a structured buffer. + + int StructureByteStride + + + + This interface encapsulates an HLSL class. + + ID3D11ClassInstance + + + + Initializes a class-instance object that represents an HLSL class instance. + + + Instances can be created (or gotten) before or after a shader is created. Use the same shader linkage object to acquire a class instance and create the shader the instance is going to be used in. For more information about using the interface, see {{Dynamic Linking}}. + + An instance of . + The type name of a class to initialize. + Identifies the constant buffer that contains the class data. + The four-component vector offset from the start of the constant buffer where the class data will begin. Consequently, this is not a byte offset. + The texture slot for the first texture; there may be multiple textures following the offset. + The sampler slot for the first sampler; there may be multiple samplers following the offset. + Returns S_OK if successful; otherwise, returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11ClassLinkage::CreateClassInstance([In] const char* pClassTypeName,[In] int ConstantBufferOffset,[In] int ConstantVectorOffset,[In] int TextureOffset,[In] int SamplerOffset,[Out] ID3D11ClassInstance** ppInstance) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Gets the object associated with the current HLSL class. + + + For more information about using the interface, see {{Dynamic Linking}}. + + A reference to a interface reference. + void ID3D11ClassInstance::GetClassLinkage([Out] ID3D11ClassLinkage** ppLinkage) + + + + Gets a description of the current HLSL class. + + + For more information about using the interface, see {{Dynamic Linking}}. An instance is not restricted to being used for a single type in a single shader. An instance is flexible and can be used for any shader that used the same type name or instance name when the instance was generated. A created instance will work for any shader that contains a type of the same type name. For instance, a class instance created with the type name DefaultShader would work in any shader that contained a type DefaultShader even though several shaders could describe a different type. A gotten instance maps directly to an instance name/index in a shader. A class instance aquired using GetClassInstance will work for any shader that contains a class instance of the name used to generate the runtime instance, the instance does not have to be the same type in all of the shaders it's used in. An instance does not replace the importance of reflection for a particular shader since a gotten instance will not know its slot location and a created instance only specifies a type name. + + A reference to a structure that describes the current HLSL class. + void ID3D11ClassInstance::GetDesc([Out] D3D11_CLASS_INSTANCE_DESC* pDesc) + + + + Gets the instance name of the current HLSL class. + + + GetInstanceName will return a valid name only for instances acquired using . For more information about using the interface, see {{Dynamic Linking}}. + + LPWSTR The instance name of the current HLSL class. + The length of the pInstanceName parameter. + void ID3D11ClassInstance::GetInstanceName([Out, Buffer, Optional] char* pInstanceName,[InOut] SIZE_T* pBufferLength) + + + + Gets the type of the current HLSL class. + + + GetTypeName will return a valid name only for instances acquired using . For more information about using the interface, see {{Dynamic Linking}}. + + Type of the current HLSL class. + The length of the pTypeName parameter. + void ID3D11ClassInstance::GetTypeName([Out, Buffer, Optional] char* pTypeName,[InOut] SIZE_T* pBufferLength) + + + + Gets the instance name of the current HLSL class. + + + GetInstanceName will return a valid name only for instances acquired using .For more information about using the interface, see {{Dynamic Linking}}. + + The instance name of the current HLSL class. + void GetInstanceName([Out, Buffer, Optional] LPSTR pInstanceName,[InOut] SIZE_T* pBufferLength) + + + + Gets the type of the current HLSL class. + + + GetTypeName will return a valid name only for instances acquired using .For more information about using the interface, see {{Dynamic Linking}}. + + Type of the current HLSL class. + void GetTypeName([Out, Buffer, Optional] LPSTR pTypeName,[InOut] SIZE_T* pBufferLength) + + + + Gets the object associated with the current HLSL class. + + + For more information about using the interface, see {{Dynamic Linking}}. + + void ID3D11ClassInstance::GetClassLinkage([Out] ID3D11ClassLinkage** ppLinkage) + + + + Gets a description of the current HLSL class. + + + For more information about using the interface, see {{Dynamic Linking}}. An instance is not restricted to being used for a single type in a single shader. An instance is flexible and can be used for any shader that used the same type name or instance name when the instance was generated. A created instance will work for any shader that contains a type of the same type name. For instance, a class instance created with the type name DefaultShader would work in any shader that contained a type DefaultShader even though several shaders could describe a different type. A gotten instance maps directly to an instance name/index in a shader. A class instance aquired using GetClassInstance will work for any shader that contains a class instance of the name used to generate the runtime instance, the instance does not have to be the same type in all of the shaders it's used in. An instance does not replace the importance of reflection for a particular shader since a gotten instance will not know its slot location and a created instance only specifies a type name. + + void ID3D11ClassInstance::GetDesc([Out] D3D11_CLASS_INSTANCE_DESC* pDesc) + + + + This interface encapsulates an HLSL dynamic linkage. + + ID3D11ClassLinkage + + + + Create a new instance of . + + + + + + Initializes a new instance of the class. + + The native pointer. + + + + Gets the class-instance object that represents the specified HLSL class. + + + For more information about using the interface, see {{Dynamic Linking}}. A class instance must have at least 1 data member in order to be available for the runtime to use with ID3D11ClassLinkage::GetClassInstance. Any instance with no members will be optimized out of a compiled shader blob as a zero-sized object. If you have a class with no data members, use instead. + + LPCWSTR The name of a class for which to get the class instance. + The index of the class instance. + The address of a reference to an interface to initialize. + HRESULT ID3D11ClassLinkage::GetClassInstance([In] const char* pClassInstanceName,[In] int InstanceIndex,[Out] ID3D11ClassInstance** ppInstance) + + + + Initializes a class-instance object that represents an HLSL class instance. + + + Instances can be created (or gotten) before or after a shader is created. Use the same shader linkage object to acquire a class instance and create the shader the instance is going to be used in. For more information about using the interface, see {{Dynamic Linking}}. + + The type name of a class to initialize. + Identifies the constant buffer that contains the class data. + The four-component vector offset from the start of the constant buffer where the class data will begin. Consequently, this is not a byte offset. + The texture slot for the first texture; there may be multiple textures following the offset. + The sampler slot for the first sampler; there may be multiple samplers following the offset. + The address of a reference to an interface to initialize. + Returns S_OK if successful; otherwise, returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11ClassLinkage::CreateClassInstance([In] const char* pClassTypeName,[In] int ConstantBufferOffset,[In] int ConstantVectorOffset,[In] int TextureOffset,[In] int SamplerOffset,[Out] ID3D11ClassInstance** ppInstance) + + + + A compute-shader interface manages an executable program (a compute shader) that controls the compute-shader stage. + + ID3D11ComputeShader + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + A dynamic class linkage interface. + + + + Initializes a new instance of the class. + + The native pointer. + + + + This interface encapsulates methods for measuring GPU performance. + + ID3D11Counter + + + + This interface encapsulates methods for retrieving data from the GPU asynchronously. + + ID3D11Asynchronous + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the size of the data (in bytes) that is output when calling . + + Size of the data (in bytes) that is output when calling GetData. + int ID3D11Asynchronous::GetDataSize() + + + + Get the size of the data (in bytes) that is output when calling . + + int ID3D11Asynchronous::GetDataSize() + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The counter description. + The newly created object. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a counter description. + + Pointer to a counter description (see ). + void ID3D11Counter::GetDesc([Out] D3D11_COUNTER_DESC* pDesc) + + + + Get a counter description. + + void ID3D11Counter::GetDesc([Out] D3D11_COUNTER_DESC* pDesc) + + + + Counter metadata that contains the type, name, units of measure, and a description of an existing counter. + + + + + Gets the data type of a counter (see ). + + The type. + + + + Gets the number of hardware counters that are needed for this counter type to be created. All instances of the same counter type use the same hardware counters. + + The hardware counter count. + + + + Gets a brief name for the counter. + + The name. + + + + Gets the units a counter measures. + + The units. + + + + Gets a description of the counter. + + The description. + + + + A debug interface controls debug settings, validates pipeline state and can only be used if the debug layer is turned on. + + ID3D11Debug + + + + Initializes a new instance of the class. + + The device. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set a bitfield of flags that will turn debug features on and off. + + + Setting a feature-mask flag will cause a rendering-operation method (listed below) to do some extra task when called. The possible feature flags are: D3D11_DEBUG_FEATURE_FINISH_PER_RENDER_OPApplication will wait for the GPU to finish processing the rendering operation before continuing. D3D11_DEBUG_FEATURE_FLUSH_PER_RENDER_OPRuntime will additionally call . D3D11_DEBUG_FEATURE_PRESENT_PER_RENDER_OPRuntime will call . Presentation of render buffers will occur according to the settings established by prior calls to and . ? These feature-mask flags apply to the following rendering-operation methods: + + Feature-mask flags bitwise ORed together. If a flag is present, then that feature will be set to on, otherwise the feature will be set to off. See remarks for a list of flags. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Debug::SetFeatureMask([None] int Mask) + + + + Get a bitfield of flags that indicates which debug features are on or off. + + Mask of feature-mask flags bitwise ORed together. If a flag is present, then that feature will be set to on, otherwise the feature will be set to off. See for a list of possible feature-mask flags. + int ID3D11Debug::GetFeatureMask() + + + + Set the number of milliseconds to sleep after is called. + + + The application will only sleep if D3D11_DEBUG_FEATURE_PRESENT_PER_RENDER_OP is a set in the {{feature mask}}. If that flag is not set the number of milliseconds is set but ignored and the application does not sleep. 10ms is used as a default value if this method is never called. + + Number of milliseconds to sleep after Present is called. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Debug::SetPresentPerRenderOpDelay([None] int Milliseconds) + + + + Get the number of milliseconds to sleep after is called. + + + Value is set with . + + Number of milliseconds to sleep after Present is called. + int ID3D11Debug::GetPresentPerRenderOpDelay() + + + + Set a swap chain that the runtime will use for automatically calling . + + + The swap chain set by this method will only be used if D3D11_DEBUG_FEATURE_PRESENT_PER_RENDER_OP is set in the {{feature mask}}. + + Swap chain that the runtime will use for automatically calling ; must have been created with the DXGI_SWAP_EFFECT_SEQUENTIAL swap-effect flag. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Debug::SetSwapChain([In, Optional] IDXGISwapChain* pSwapChain) + + + + Get the swap chain that the runtime will use for automatically calling . + + + The swap chain retrieved by this method will only be used if D3D11_DEBUG_FEATURE_PRESENT_PER_RENDER_OP is set in the {{feature mask}}. + + Swap chain that the runtime will use for automatically calling . + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Debug::GetSwapChain([Out] IDXGISwapChain** ppSwapChain) + + + + Check to see if the draw pipeline state is valid. + + + Use validate prior to calling a draw method (for example, ); validation requires the debug layer. + + A reference to the , that represents a device context. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Debug::ValidateContext([In] ID3D11DeviceContext* pContext) + + + + Report information about a device object's lifetime. + + + ReportLiveDeviceObjects uses the value in Flags to determine the amount of information to report about a device object's lifetime. + + A value from the enumeration. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Debug::ReportLiveDeviceObjects([None] D3D11_RLDO_FLAGS Flags) + + + + Verifies whether the dispatch pipeline state is valid. + + + Use this method before you call a dispatch method (for example, ). Validation requires the debug layer. + + A reference to the that represents a device context. + This method returns one of the return codes described in the topic {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Debug::ValidateContextForDispatch([In] ID3D11DeviceContext* pContext) + + + + Gets or sets the feature flags that indicates which debug features are on or off. + + The feature flags. + + + + Get the number of milliseconds to sleep after is called. + + + Value is set with . + + int ID3D11Debug::GetPresentPerRenderOpDelay() + + + + Get the swap chain that the runtime will use for automatically calling . + + + The swap chain retrieved by this method will only be used if D3D11_DEBUG_FEATURE_PRESENT_PER_RENDER_OP is set in the {{feature mask}}. + + HRESULT ID3D11Debug::GetSwapChain([Out] IDXGISwapChain** ppSwapChain) + + + + A depth-stencil-state interface accesses depth-stencil state which sets up the depth-stencil test for the output-merger stage. + + ID3D11DepthStencilState + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the depth-stencil state. + + A reference to the depth-stencil state (see ). + void ID3D11DepthStencilState::GetDesc([Out] D3D11_DEPTH_STENCIL_DESC* pDesc) + + + + Get the depth-stencil state. + + void ID3D11DepthStencilState::GetDesc([Out] D3D11_DEPTH_STENCIL_DESC* pDesc) + + + + A depth-stencil-view interface accesses a texture resource during depth-stencil testing. + + ID3D11DepthStencilView + + + + A view interface specifies the parts of a resource the pipeline can access during rendering. + + ID3D11View + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the resource that is accessed through this view. + + + This function increments the reference count of the resource by one, so it is necessary to call Release on the returned reference when the application is done with it. Destroying (or losing) the returned reference before Release is called will result in a memory leak. + + Address of a reference to the resource that is accessed through this view. (See .) + void ID3D11View::GetResource([Out] ID3D11Resource** ppResource) + + + + Get the resource that is accessed through this view. + + + This function increments the reference count of the resource by one, so it is necessary to call Release on the returned reference when the application is done with it. Destroying (or losing) the returned reference before Release is called will result in a memory leak. + + void ID3D11View::GetResource([Out] ID3D11Resource** ppResource) + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the DepthStencil flag. + ID3D11Device::CreateDepthStencilView + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the DepthStencil flag. + A structure describing the to be created. + ID3D11Device::CreateDepthStencilView + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the depth-stencil view. + + Pointer to a depth-stencil-view description (see ). + void ID3D11DepthStencilView::GetDesc([Out] D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc) + + + + Get the depth-stencil view. + + void ID3D11DepthStencilView::GetDesc([Out] D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc) + + + + The device interface represents a virtual adapter; it is used to create resources. + + ID3D11Device + + + + Constructor for a D3D11 Device. See for more information. + + + + + + Constructor for a D3D11 Device. See for more information. + + + + + + Constructor for a D3D11 Device. See for more information. + + + + + + + Constructor for a D3D11 Device. See for more information. + + + + + + + Constructor for a D3D11 Device. See for more information. + + + + + + + + Constructor for a D3D11 Device. See for more information. + + + + + + + + Internal CreateDevice + + + + + + + + + Initializes a new instance of the class along with a new used for rendering. + + The type of device to create. + A list of runtime layers to enable. + Details used to create the swap chain. + When the method completes, contains the created device instance. + When the method completes, contains the created swap chain instance. + A object describing the result of the operation. + + + + Initializes a new instance of the class along with a new used for rendering. + + The video adapter on which the device should be created. + A list of runtime layers to enable. + Details used to create the swap chain. + When the method completes, contains the created device instance. + When the method completes, contains the created swap chain instance. + A object describing the result of the operation. + + + + Initializes a new instance of the class along with a new used for rendering. + + The type of device to create. + A list of runtime layers to enable. + A list of feature levels which determine the order of feature levels to attempt to create. + Details used to create the swap chain. + When the method completes, contains the created device instance. + When the method completes, contains the created swap chain instance. + A object describing the result of the operation. + + + + Initializes a new instance of the class along with a new used for rendering. + + The video adapter on which the device should be created. + A list of runtime layers to enable. + A list of feature levels which determine the order of feature levels to attempt to create. + Details used to create the swap chain. + When the method completes, contains the created device instance. + When the method completes, contains the created swap chain instance. + A object describing the result of the operation. + + + + This overload has been deprecated. Use one of the alternatives that does not take both an adapter and a driver type. + + + + + Release COM reference + + + + + + Get the type, name, units of measure, and a description of an existing counter. + + The counter description. + Description of the counter + + + + Give a device access to a shared resource created on a different Direct3d device. + + The type of the resource we are gaining access to. + A resource handle. See remarks. + + This method returns a reference to the resource we are gaining access to. + + + To share a resource between two Direct3D 10 devices the resource must have been created with the flag, if it was created using the ID3D10Device interface. If it was created using the IDXGIDevice interface, then the resource is always shared. The REFIID, or GUID, of the interface to the resource can be obtained by using the __uuidof() macro. For example, __uuidof(ID3D10Buffer) will get the GUID of the interface to a buffer resource. When sharing a resource between two Direct3D 10 devices the unique handle of the resource can be obtained by querying the resource for the interface and then calling {{GetSharedHandle}}. + IDXGIResource* pOtherResource(NULL); + hr = pOtherDeviceResource->QueryInterface( __uuidof(IDXGIResource), (void**)&pOtherResource ); + HANDLE sharedHandle; + pOtherResource->GetSharedHandle(&sharedHandle); + The only resources that can be shared are 2D non-mipmapped textures. To share a resource between a Direct3D 9 device and a Direct3D 10 device the texture must have been created using the pSharedHandle argument of {{CreateTexture}}. The shared Direct3D 9 handle is then passed to OpenSharedResource in the hResource argument. The following code illustrates the method calls involved. + sharedHandle = NULL; // must be set to NULL to create, can use a valid handle here to open in D3D9 + pDevice9->CreateTexture(..., pTex2D_9, &sharedHandle); + ... + pDevice10->OpenSharedResource(sharedHandle, __uuidof(ID3D10Resource), (void**)(&tempResource10)); + tempResource10->QueryInterface(__uuidof(ID3D10Texture2D), (void**)(&pTex2D_10)); + tempResource10->Release(); + // now use pTex2D_10 with pDevice10 + Textures being shared from D3D9 to D3D10 have the following restrictions. Textures must be 2D Only 1 mip level is allowed Texture must have default usage Texture must be write only MSAA textures are not allowed Bind flags must have SHADER_RESOURCE and RENDER_TARGET set Only R10G10B10A2_UNORM, R16G16B16A16_FLOAT and R8G8B8A8_UNORM formats are allowed If a shared texture is updated on one device must be called on that device. + + HRESULT ID3D10Device::OpenSharedResource([In] void* hResource,[In] GUID* ReturnedInterface,[Out, Optional] void** ppResource) + + + + Check if this device is supporting compute shaders for the specified format. + + The format for which to check support. + Flags indicating usage contexts in which the specified format is supported. + + + + Check if this device is supporting a feature. + + The feature to check. + Returns true if this device supports this feature, otherwise false. + + + + Check if this device is supporting threading. + + Support concurrent resources. + Support command lists. + A object describing the result of the operation. + + + + Gets the highest supported hardware feature level of the primary adapter. + + The highest supported hardware feature level. + + + + Gets the highest supported hardware feature level of the primary adapter. + + The adapter. + + The highest supported hardware feature level. + + + + + Initializes a new instance of the class. + + The native pointer. + + + + Create a buffer (vertex buffer, index buffer, or shader-constant buffer). + + + For example code, see {{How to: Create a Vertex Buffer}}, {{How to: Create an Index Buffer}} or {{How to: Create a Constant Buffer}}. + + Pointer to a buffer description (see ). + Pointer to the initialization data (see ); use NULL to allocate space only (with the exception that it cannot be NULL if the usage flag is D3D11_USAGE_IMMUTABLE). + Address of a reference to the buffer created (see ). Set this parameter to NULL to validate the other input parameters (S_FALSE indicates a pass). + This method returns E_OUTOFMEMORY if there is insufficient memory to create the buffer. See {{Direct3D 11 Return Codes}} for other possible return values. + HRESULT ID3D11Device::CreateBuffer([In] const D3D11_BUFFER_DESC* pDesc,[In, Optional] const D3D11_SUBRESOURCE_DATA* pInitialData,[Out, Optional] ID3D11Buffer** ppBuffer) + + + + Create an array of {{1D textures}}. + + + CreateTexture1D creates a 1D texture resource, which can contain a number of 1D subresources. The number of textures is specified in the texture description. All textures in a resource must have the same format, size, and number of mipmap levels. All resources are made up of one or more subresources. To load data into the texture, applications may supply the data initially as part of structure pointed to by pInitialData, or it may use one of the D3DX texture functions such as {{D3DX11CreateTextureFromFile}}. + + Pointer to a 1D texture description (see ). To create a typeless resource that can be interpreted at runtime into different, compatible formats, specify a typeless format in the texture description. To generate mipmap levels automatically, set the number of mipmap levels to 0. + Pointer to an array of subresource descriptions (see ); one for each subresource. Applications may not specify NULL for pInitialData when creating IMMUTABLE resources (see ). If the resource is multisampled, pInitialData must be NULL because multisampled resources cannot be initialized with data when they are created. + Address of a reference to the created texture (see ). Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). + If the method succeeds, the return code is S_OK. See {{Direct3D 11 Return Codes}} for failing error codes. + HRESULT ID3D11Device::CreateTexture1D([In] const D3D11_TEXTURE1D_DESC* pDesc,[In, Buffer, Optional] const D3D11_SUBRESOURCE_DATA* pInitialData,[Out, Optional] ID3D11Texture1D** ppTexture1D) + + + + Create an array of {{2D textures}}. + + + CreateTexture2D creates a 2D texture resource, which can contain a number of 2D subresources. The number of textures is specified in the texture description. All textures in a resource must have the same format, size, and number of mipmap levels. All resources are made up of one or more subresources. To load data into the texture, applications may supply the data initially as part of structure pointed to by pInitialData, or it may use one of the D3DX texture functions such as {{D3DX11CreateTextureFromFile}}. + + Pointer to a 2D texture description (see ). To create a typeless resource that can be interpreted at runtime into different, compatible formats, specify a typeless format in the texture description. To generate mipmap levels automatically, set the number of mipmap levels to 0. + Pointer to an array of subresource descriptions (see ); one for each subresource. Applications may not specify NULL for pInitialData when creating IMMUTABLE resources (see ). If the resource is multisampled, pInitialData must be NULL because multisampled resources cannot be initialized with data when they are created. + Address of a reference to the created texture (see ). Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). + If the method succeeds, the return code is S_OK. See {{Direct3D 11 Return Codes}} for failing error codes. + HRESULT ID3D11Device::CreateTexture2D([In] const D3D11_TEXTURE2D_DESC* pDesc,[In, Buffer, Optional] const D3D11_SUBRESOURCE_DATA* pInitialData,[Out, Optional] ID3D11Texture2D** ppTexture2D) + + + + Create a single {{3D texture}}. + + + CreateTexture3D creates a 3D texture resource, which can contain a number of 3D subresources. The number of textures is specified in the texture description. All textures in a resource must have the same format, size, and number of mipmap levels. All resources are made up of one or more subresources. To load data into the texture, applications may supply the data initially as part of structure pointed to by pInitialData, or it may use one of the D3DX texture functions such as {{D3DX11CreateTextureFromFile}}. + + Pointer to a 3D texture description (see ). To create a typeless resource that can be interpreted at runtime into different, compatible formats, specify a typeless format in the texture description. To generate mipmap levels automatically, set the number of mipmap levels to 0. + Pointer to an array of subresource descriptions (see ); one for each subresource. Applications may not specify NULL for pInitialData when creating IMMUTABLE resources (see ). If the resource is multisampled, pInitialData must be NULL because multisampled resources cannot be initialized with data when they are created. + Address of a reference to the created texture (see ). Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). + If the method succeeds, the return code is S_OK. See {{Direct3D 11 Return Codes}} for failing error codes. + HRESULT ID3D11Device::CreateTexture3D([In] const D3D11_TEXTURE3D_DESC* pDesc,[In, Buffer, Optional] const D3D11_SUBRESOURCE_DATA* pInitialData,[Out, Optional] ID3D11Texture3D** ppTexture3D) + + + + Create a shader-resource view for accessing data in a resource. + + + A resource is made up of one or more subresources, a view identifies which subresources to allow the pipeline to access. In addition, each resource is bound to the pipeline using a view. A shader-resource view is designed to bind any buffer or texture resource to the shader stages using the following API methods: , and . Since a view is fully typed, this means that typeless resources become fully typed when bound to the pipeline. + + Pointer to the resource that will serve as input to a shader. This resource must have been created with the flag. + Pointer to a shader-resource-view description (see ). Set this parameter to NULL to create a view that accesses the entire resource (using the format the resource was created with). + Address of a reference to an . Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::CreateShaderResourceView([In] ID3D11Resource* pResource,[In, Optional] const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc,[Out, Optional] ID3D11ShaderResourceView** ppSRView) + + + + Create a view for accessing an {{unordered access}} resource. + + Pointer to an that represents a resources that will be serve as an input to a shader. + Pointer to an that represents a shader-resource-view description. Set this parameter to NULL to create a view that accesses the entire resource (using the format the resource was created with). + Address of a reference to an that represents an unordered access view. Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::CreateUnorderedAccessView([In] ID3D11Resource* pResource,[In, Optional] const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc,[Out, Optional] ID3D11UnorderedAccessView** ppUAView) + + + + Create a render-target view for accessing resource data. + + + A rendertarget view can be bound to the output-merger stage by calling . + + Pointer to a which represents a render target. This resource must have been created with the flag. + Pointer to a which represents a render-target-view description. Set this parameter to NULL to create a view that accesses all of the subresources in mipmap level 0. + Address of a reference to an . Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::CreateRenderTargetView([In] ID3D11Resource* pResource,[In, Optional] const D3D11_RENDER_TARGET_VIEW_DESC* pDesc,[Out, Optional] ID3D11RenderTargetView** ppRTView) + + + + Create a depth-stencil view for accessing resource data. + + + A depth-stencil view can be bound to the output-merger stage by calling . + + Pointer to the resource that will serve as the depth-stencil surface. This resource must have been created with the flag. + Pointer to a depth-stencil-view description (see ). Set this parameter to NULL to create a view that accesses mipmap level 0 of the entire resource (using the format the resource was created with). + Address of a reference to an . Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::CreateDepthStencilView([In] ID3D11Resource* pResource,[In, Optional] const D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc,[Out, Optional] ID3D11DepthStencilView** ppDepthStencilView) + + + + Create an input-layout object to describe the input-buffer data for the input-assembler stage. + + + After creating an input layout object, it must be bound to the input-assembler stage before calling a draw API. Once an input-layout object is created from a shader signature, the input-layout object can be reused with any other shader that has an identical input signature (semantics included). This can simplify the creation of input-layout objects when you are working with many shaders with identical inputs. If a data type in the input-layout declaration does not match the data type in a shader-input signature, CreateInputLayout will generate a warning during compilation. The warning is simply to call attention to the fact that the data may be reinterpreted when read from a register. You may either disregard this warning (if reinterpretation is intentional) or make the data types match in both declarations to eliminate the warning. + + An array of the input-assembler stage input data types; each type is described by an element description (see ). + The number of input-data types in the array of input-elements. + void A reference to the compiled shader. The compiled shader code contains a input signature which is validated against the array of elements. See remarks. + Size of the compiled shader. + A reference to the input-layout object created (see ). To validate the other input parameters, set this reference to be NULL and verify that the method returns S_FALSE. + If the method succeeds, the return code is S_OK. See {{Direct3D 11 Return Codes}} for failing error codes. + HRESULT ID3D11Device::CreateInputLayout([In, Buffer] const D3D11_INPUT_ELEMENT_DESC* pInputElementDescs,[In] int NumElements,[In] const void* pShaderBytecodeWithInputSignature,[In] SIZE_T BytecodeLength,[Out, Optional] ID3D11InputLayout** ppInputLayout) + + + + Create a vertex-shader object from a compiled shader. + + void A reference to the compiled shader. + Size of the compiled vertex shader. + A reference to a class linkage interface (see ); the value can be NULL. + Address of a reference to a interface. If this is NULL, all other parameters will be validated, and if all parameters pass validation this API will return S_FALSE instead of S_OK. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::CreateVertexShader([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In, Optional] ID3D11ClassLinkage* pClassLinkage,[Out, Optional] ID3D11VertexShader** ppVertexShader) + + + + Create a geometry shader. + + + Once created, the shader can be set to the device by calling . + + void A reference to the compiled shader. + Size of the compiled geometry shader. + A reference to a class linkage interface (see ); the value can be NULL. + Address of a reference to a interface. If this is NULL, all other parameters will be validated, and if all parameters pass validation this API will return S_FALSE instead of S_OK. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::CreateGeometryShader([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In, Optional] ID3D11ClassLinkage* pClassLinkage,[Out, Optional] ID3D11GeometryShader** ppGeometryShader) + + + + Create a geometry shader that can write to streaming output buffers. + + void A reference to the compiled shader. + Size of the compiled geometry shader. + Pointer to a array. Cannot be NULL if NumEntries > 0. + The number of entries in the stream output declaration ( ranges from 0 to D3D11_SO_STREAM_COUNT * D3D11_SO_OUTPUT_COMPONENT_COUNT ). + An array of buffer strides; each stride is the size of an element for that buffer. + The number of strides (or buffers) in pBufferStrides (ranges from 0 to D3D11_SO_BUFFER_SLOT_COUNT). + The index number of the stream to be sent to the rasterizer stage (ranges from 0 to D3D11_SO_STREAM_COUNT - 1). Set to D3D11_SO_NO_RASTERIZED_STREAM if no stream is to be rasterized. + A reference to a class linkage interface (see ); the value can be NULL. + Address of a reference to an interface, representing the geometry shader that was created. Set this to NULL to validate the other parameters; if validation passes, the method will return S_FALSE instead of S_OK. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::CreateGeometryShaderWithStreamOutput([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In, Buffer, Optional] const D3D11_SO_DECLARATION_ENTRY* pSODeclaration,[In] int NumEntries,[In, Buffer, Optional] const int* pBufferStrides,[In] int NumStrides,[In] int RasterizedStream,[In, Optional] ID3D11ClassLinkage* pClassLinkage,[Out, Optional] ID3D11GeometryShader** ppGeometryShader) + + + + Create a pixel shader. + + + After creating the pixel shader, you can set it to the device using . + + void A reference to the compiled shader. + Size of the compiled pixel shader. + A reference to a class linkage interface (see ); the value can be NULL. + Address of a reference to a interface. If this is NULL, all other parameters will be validated, and if all parameters pass validation this API will return S_FALSE instead of S_OK. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::CreatePixelShader([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In, Optional] ID3D11ClassLinkage* pClassLinkage,[Out, Optional] ID3D11PixelShader** ppPixelShader) + + + + Create a {{hull shader}}. + + void A reference to a compiled shader. + Size of the compiled shader. + A reference to a class linkage interface (see ); the value can be NULL. + A reference to a hull-shader interface (see ). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::CreateHullShader([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In, Optional] ID3D11ClassLinkage* pClassLinkage,[Out, Optional] ID3D11HullShader** ppHullShader) + + + + Create a {{domain shader}} . + + void A reference to a compiled shader. + Size of the compiled shader. + A reference to a class linkage interface (see ); the value can be NULL. + Address of a reference to a interface. If this is NULL, all other parameters will be validated, and if all parameters pass validation this API will return S_FALSE instead of S_OK. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::CreateDomainShader([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In, Optional] ID3D11ClassLinkage* pClassLinkage,[Out, Optional] ID3D11DomainShader** ppDomainShader) + + + + Create a {{compute shader}}. + + + For an example, see {{How To: Create a Compute Shader}} and {{HDRToneMappingCS11 Sample}}. + + void A reference to a compiled shader. + Size of the compiled shader in pShaderBytecode. + A reference to a , which represents class linkage interface; the value can be NULL. + Address of a reference to an interface. If this is NULL, all other parameters will be validated; if validation passes, CreateComputeShader returns S_FALSE instead of S_OK. + This method returns E_OUTOFMEMORY if there is insufficient memory to create the compute shader. See {{Direct3D 11 Return Codes}} for other possible return values. + HRESULT ID3D11Device::CreateComputeShader([In] const void* pShaderBytecode,[In] SIZE_T BytecodeLength,[In, Optional] ID3D11ClassLinkage* pClassLinkage,[Out, Optional] ID3D11ComputeShader** ppComputeShader) + + + + Creates class linkage libraries to enable dynamic shader linkage. + + + The interface returned in ppLinkage is associated with a shader by passing it as a parameter to one of the create shader methods such as . + + A reference to a class-linkage interface reference (see ). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::CreateClassLinkage([Out] ID3D11ClassLinkage** ppLinkage) + + + + Create a blend-state object that encapsules blend state for the output-merger stage. + + + An application can create up to 4096 unique blend-state objects. For each object created, the runtime checks to see if a previous object has the same state. If such a previous object exists, the runtime will return a reference to previous instance instead of creating a duplicate object. + + Pointer to a blend-state description (see ). + Address of a reference to the blend-state object created (see ). + This method returns E_OUTOFMEMORY if there is insufficient memory to create the blend-state object. See {{Direct3D 11 Return Codes}} for other possible return values. + HRESULT ID3D11Device::CreateBlendState([In] const D3D11_BLEND_DESC* pBlendStateDesc,[Out, Optional] ID3D11BlendState** ppBlendState) + + + + Create a depth-stencil state object that encapsulates depth-stencil test information for the output-merger stage. + + + 4096 unique depth-stencil state objects can be created on a device at a time. If an application attempts to create a depth-stencil-state interface with the same state as an existing interface, the same interface will be returned and the total number of unique depth-stencil state objects will stay the same. + + Pointer to a depth-stencil state description (see ). + Address of a reference to the depth-stencil state object created (see ). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::CreateDepthStencilState([In] const D3D11_DEPTH_STENCIL_DESC* pDepthStencilDesc,[Out, Optional] ID3D11DepthStencilState** ppDepthStencilState) + + + + Create a rasterizer state object that tells the rasterizer stage how to behave. + + + 4096 unique rasterizer state objects can be created on a device at a time. If an application attempts to create a rasterizer-state interface with the same state as an existing interface, the same interface will be returned and the total number of unique rasterizer state objects will stay the same. + + Pointer to a rasterizer state description (see ). + Address of a reference to the rasterizer state object created (see ). + This method returns E_OUTOFMEMORY if there is insufficient memory to create the compute shader. See {{Direct3D 11 Return Codes}} for other possible return values. + HRESULT ID3D11Device::CreateRasterizerState([In] const D3D11_RASTERIZER_DESC* pRasterizerDesc,[Out, Optional] ID3D11RasterizerState** ppRasterizerState) + + + + Create a sampler-state object that encapsulates sampling information for a texture. + + + 4096 unique sampler state objects can be created on a device at a time. If an application attempts to create a sampler-state interface with the same state as an existing interface, the same interface will be returned and the total number of unique sampler state objects will stay the same. + + Pointer to a sampler state description (see ). + Address of a reference to the sampler state object created (see ). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::CreateSamplerState([In] const D3D11_SAMPLER_DESC* pSamplerDesc,[Out, Optional] ID3D11SamplerState** ppSamplerState) + + + + This interface encapsulates methods for querying information from the GPU. + + + + Pointer to a query description (see ). + Address of a reference to the query object created (see ). + This method returns E_OUTOFMEMORY if there is insufficient memory to create the compute shader. See {{Direct3D 11 Return Codes}} for other possible return values. + HRESULT ID3D11Device::CreateQuery([In] const D3D11_QUERY_DESC* pQueryDesc,[Out, Optional] ID3D11Query** ppQuery) + + + + Creates a predicate. + + Pointer to a query description where the type of query must be a D3D11_QUERY_SO_OVERFLOW_PREDICATE or D3D11_QUERY_OCCLUSION_PREDICATE (see ). + Address of a reference to a predicate (see ). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::CreatePredicate([In] const D3D11_QUERY_DESC* pPredicateDesc,[Out, Optional] ID3D11Predicate** ppPredicate) + + + + Create a counter object for measuring GPU performance. + + Pointer to a counter description (see ). + Address of a reference to a counter (see ). + If this function succeeds, it will return S_OK. If it fails, possible return values are: S_FALSE, E_OUTOFMEMORY, DXGI_ERROR_UNSUPPORTED, DXGI_ERROR_NONEXCLUSIVE, or E_INVALIDARG. DXGI_ERROR_UNSUPPORTED is returned whenever the application requests to create a well-known counter, but the current device does not support it. DXGI_ERROR_NONEXCLUSIVE indicates that another device object is currently using the counters, so they cannot be used by this device at the moment. E_INVALIDARG is returned whenever an out-of-range well-known or device-dependent counter is requested, or when the simulataneously active counters have been exhausted. + HRESULT ID3D11Device::CreateCounter([In] const D3D11_COUNTER_DESC* pCounterDesc,[Out, Optional] ID3D11Counter** ppCounter) + + + + Creates a deferred context for play back of command lists. + + + A deferred context is a thread-safe context that you can use to record graphics commands on a thread other than the main rendering thread. Using a deferred context, you can record graphics commands into a command list that is encapsulated by the interface. After all scene items are recorded, you can then submit them to the main render thread for final rendering. In this manner, you can perform rendering tasks concurrently across multiple threads and potentially improve performance in multi-core CPU scenarios. You can create multiple deferred contexts. Note??If you use the value to create the device that is represented by , the CreateDeferredContext method will fail, and you will not be able to create a deferred context. For more information about deferred contexts, see {{Immediate and Deferred Rendering}}. + + Reserved for future use. Pass 0. + Upon completion of the method, the passed reference to an interface reference is initialized. + Returns S_OK if successful; otherwise, returns one of the following: Returns DXGI_ERROR_DEVICE_REMOVED if the video card has been physically removed from the system, or a driver upgrade for the video card has occurred. If this error occurs, you should destroy and recreate the device. Returns DXGI_ERROR_INVALID_CALL if the CreateDeferredContext method cannot be called from the current context. For example, if the device was created with the value, CreateDeferredContext returns DXGI_ERROR_INVALID_CALL. Returns E_INVALIDARG if the ContextFlags parameter is invalid. Returns E_OUTOFMEMORY if the application has exhausted available memory. + HRESULT ID3D11Device::CreateDeferredContext([None] int ContextFlags,[Out, Optional] ID3D11DeviceContext** ppDeferredContext) + + + + Give a device access to a shared resource created on a different device. + + + The REFIID, or GUID, of the interface to the resource can be obtained by using the __uuidof() macro. For example, __uuidof(ID3D11Buffer) will get the GUID of the interface to a buffer resource. The unique handle of the resource is obtained differently depending on the type of device that originally created the resource. To share a resource between two Direct3D 11 devices the resource must have been created with the flag, if it was created using the ID3D11Device interface. If it was created using a DXGI device interface, then the resource is always shared. The REFIID, or GUID, of the interface to the resource can be obtained by using the __uuidof() macro. For example, __uuidof(ID3D11Buffer) will get the GUID of the interface to a buffer resource. When sharing a resource between two Direct3D 10/11 devices the unique handle of the resource can be obtained by querying the resource for the interface and then calling {{GetSharedHandle}}. + IDXGIResource* pOtherResource(NULL); + hr = pOtherDeviceResource->QueryInterface( __uuidof(IDXGIResource), (void**)&pOtherResource ); + HANDLE sharedHandle; + pOtherResource->GetSharedHandle(&sharedHandle); + + The only resources that can be shared are 2D non-mipmapped textures. To share a resource between a Direct3D 9 device and a Direct3D 11 device the texture must have been created using the pSharedHandle argument of {{CreateTexture}}. The shared Direct3D 9 handle is then passed to OpenSharedResource in the hResource argument. The following code illustrates the method calls involved. + sharedHandle = NULL; // must be set to NULL to create, can use a valid handle here to open in D3D9 + pDevice9->CreateTexture(..., pTex2D_9, &sharedHandle); + ... + pDevice11->OpenSharedResource(sharedHandle, __uuidof(ID3D11Resource), (void**)(&tempResource11)); + tempResource11->QueryInterface(__uuidof(ID3D11Texture2D), (void**)(&pTex2D_11)); + tempResource11->Release(); + // now use pTex2D_11 with pDevice11 + + Textures being shared from D3D9 to D3D11 have the following restrictions. Textures must be 2D Only 1 mip level is allowed Texture must have default usage Texture must be write only MSAA textures are not allowed Bind flags must have SHADER_RESOURCE and RENDER_TARGET set Only R10G10B10A2_UNORM, R16G16B16A16_FLOAT and R8G8B8A8_UNORM formats are allowed If a shared texture is updated on one device must be called on that device. + + A resource handle. See remarks. + REFIID The globally unique identifier (GUID) for the resource interface. See remarks. + void Address of a reference to the resource we are gaining access to. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::OpenSharedResource([In] void* hResource,[In] GUID* ReturnedInterface,[Out, Optional] void** ppResource) + + + + Get the support of a given format on the installed video device. + + A enumeration that describes a format for which to check for support. + A bitfield of enumeration values describing how the specified format is supported on the installed device. The values are ORed together. + HRESULT ID3D11Device::CheckFormatSupport([In] DXGI_FORMAT Format,[Out] D3D11_FORMAT_SUPPORT* pFormatSupport) + + + + Get the number of quality levels available during multisampling. + + + When multisampling a texture, the number of quality levels available for an adapter is dependent on the texture format used and the number of samples requested. The maximum number of quality levels is defined by D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT in D3D11.h. If this method returns 0, the format and sample count combination is not supported for the installed adapter. Furthermore, the definition of a quality level is up to each hardware vendor to define, however no facility is provided by Direct3D to help discover this information. Note that FEATURE_LEVEL_10_1 devices are required to support 4x MSAA for all render targets except R32G32B32A32 and R32G32B32. FEATURE_LEVEL_11_0 devices are required to support 4x MSAA for all render target formats, and 8x MSAA for all render target formats except R32G32B32A32 formats. + + The texture format. See . + The number of samples during multisampling. + Number of quality levels supported by the adapter. See remarks. + HRESULT ID3D11Device::CheckMultisampleQualityLevels([In] DXGI_FORMAT Format,[In] int SampleCount,[Out] int* pNumQualityLevels) + + + + Get a counter's information. + + void ID3D11Device::CheckCounterInfo([Out] D3D11_COUNTER_INFO* pCounterInfo) + + + + Get the type, name, units of measure, and a description of an existing counter. + + + Length parameters can be NULL, which indicates the application is not interested in the length nor the corresponding string value. When a length parameter is non-NULL and the corresponding string is NULL, the input value of the length parameter is ignored, and the length of the corresponding string (including terminating NULL) will be returned through the length parameter. When length and the corresponding parameter are both non-NULL, the input value of length is checked to ensure there is enough room, and then the length of the string (including terminating NULL character) is passed out through the length parameter. + + Pointer to a counter description (see ). Specifies which counter information is to be retrieved about. + Pointer to the data type of a counter (see ). Specifies the data type of the counter being retrieved. + Pointer to the number of hardware counters that are needed for this counter type to be created. All instances of the same counter type use the same hardware counters. + String to be filled with a brief name for the counter. May be NULL if the application is not interested in the name of the counter. + Length of the string returned to szName. Can be NULL. + Name of the units a counter measures, provided the memory the reference points to has enough room to hold the string. Can be NULL. The returned string will always be in English. + Length of the string returned to szUnits. Can be NULL. + A description of the counter, provided the memory the reference points to has enough room to hold the string. Can be NULL. The returned string will always be in English. + Length of the string returned to szDescription. Can be NULL. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::CheckCounter([In] const D3D11_COUNTER_DESC* pDesc,[Out] D3D11_COUNTER_TYPE* pType,[Out] int* pActiveCounters,[Out, Buffer, Optional] char* szName,[InOut, Optional] int* pNameLength,[Out, Buffer, Optional] char* szUnits,[InOut, Optional] int* pUnitsLength,[Out, Buffer, Optional] char* szDescription,[InOut, Optional] int* pDescriptionLength) + + + + Gets information about the features that are supported by the current graphics driver. + + + To query for multi-threading support, pass the D3D11_FEATURE_THREADING value to the Feature parameter, pass the structure to the pFeatureSupportData parameter, and pass the size of the D3D11_FEATURE_DATA_THREADING structure to the FeatureSupportDataSize parameter. Calling CheckFeatureSupport with Feature set to D3D11_FEATURE_FORMAT_SUPPORT causes the method to return the same information that would be returned by . + + A member of the enumerated type that describes which feature to query for support. + void Upon completion of the method, the passed structure is filled with data that describes the feature support. + The size of the structure passed to the pFeatureSupportData parameter. + Returns S_OK if successful; otherwise, returns E_INVALIDARG if an unsupported data type is passed to the pFeatureSupportData parameter or a size mismatch is detected for the FeatureSupportDataSize parameter. + HRESULT ID3D11Device::CheckFeatureSupport([None] D3D11_FEATURE Feature,[Out, Buffer] void* pFeatureSupportData,[None] int FeatureSupportDataSize) + + + + Get application-defined data from a device. + + Guid associated with the data. + A reference to a variable that on input contains the size, in bytes, of the buffer that pData points to, and on output contains the size, in bytes, of the amount of data that GetPrivateData retrieved. + void A reference to a buffer that GetPrivateData fills with data from the device if pDataSize points to a value that specifies a buffer large enough to hold the data. + This method returns one of the codes described in the topic {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::GetPrivateData([In] GUID* guid,[InOut] int* pDataSize,[Out, Buffer, Optional] void* pData) + + + + Set data to a device and associate that data with a guid. + + + The data stored in the device with this method can be retrieved with . The data and guid set with this method will typically be application-defined. If an application uses this method to change the device type using GUID_DeviceType, results are undefined. However, GUID_DeviceType can be used to retrieve the device type using . The {{debug layer}} reports memory leaks by outputting a list of object interface references along with their friendly names. The default friendly name is "<unnamed>". You can set the friendly name so that you can determine if the corresponding object interface reference caused the leak. To set the friendly name, use the SetPrivateData method and the WKPDID_D3DDebugObjectName GUID that is in D3Dcommon.h. For example, to give pContext a friendly name of My name, use the following code: + static const char c_szName[] = "My name"; + hr = pContext->SetPrivateData( WKPDID_D3DDebugObjectName, sizeof( c_szName ) - 1, c_szName ); + + + + Guid associated with the data. + Size of the data. + void Pointer to the data to be stored with this device. If pData is NULL, DataSize must also be 0, and any data previously associated with the guid will be destroyed. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::SetPrivateData([In] GUID* guid,[In] int DataSize,[In, Buffer, Optional] const void* pData) + + + + Associate an IUnknown-derived interface with this device child and associate that interface with an application-defined guid. + + Guid associated with the interface. + IUnknown Pointer to an IUnknown-derived interface to be associated with the device child. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::SetPrivateDataInterface([In] GUID* guid,[In, Optional] const IUnknown* pData) + + + + Gets the feature level of the hardware device. + + + {{Feature levels}} determine the capabilities of your device. + + A member of the enumerated type that describes the feature level of the hardware device. + D3D_FEATURE_LEVEL ID3D11Device::GetFeatureLevel() + + + + Get the flags used during the call to create the device with . + + A bitfield containing the flags used to create the device. See . + int ID3D11Device::GetCreationFlags() + + + + Get the reason why the device was removed. + + Possible return values include: DXGI_ERROR_DEVICE_HUNG DXGI_ERROR_DEVICE_REMOVED DXGI_ERROR_DEVICE_RESET DXGI_ERROR_DRIVER_INTERNAL_ERROR DXGI_ERROR_INVALID_CALL S_OK For more detail on these return codes, see . + HRESULT ID3D11Device::GetDeviceRemovedReason() + + + + Gets an immediate context which can record command lists. + + + The GetImmediateContext method returns an object that represents an immediate context which is used to perform rendering that you want immediately submitted to a device. For most applications, an immediate context is the primary object that is used to draw your scene. + + Upon completion of the method, the passed reference to an interface reference is initialized. + void ID3D11Device::GetImmediateContext([Out] ID3D11DeviceContext** ppImmediateContext) + + + + Get the exception-mode flags. + + + Set an exception-mode flag to elevate an error condition to a non-continuable exception. Whenever an error occurs, a Direct3D device enters the DEVICEREMOVED state and if the appropriate exception flag has been set, an exception is raised. A raised exception is designed to terminate an application. Before termination, the last chance an application has to persist data is by using an UnhandledExceptionFilter (see {{Structured Exception Handling}}). In general, UnhandledExceptionFilters are leveraged to try to persist data when an application is crashing (to disk, for example). Any code that executes during an UnhandledExceptionFilter is not guaranteed to reliably execute (due to possible process corruption). Any data that the UnhandledExceptionFilter manages to persist, before the UnhandledExceptionFilter crashes again, should be treated as suspect, and therefore inspected by a new, non-corrupted process to see if it is usable. + + A value that contains one or more exception flags; each flag specifies a condition which will cause an exception to be raised. The flags are listed in {{D3D11_RAISE_FLAG}}. A default value of 0 means there are no flags. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11Device::SetExceptionMode([None] int RaiseFlags) + + + + Get the exception-mode flags. + + + An exception-mode flag is used to elevate an error condition to a non-continuable exception. + + A value that contains one or more exception flags; each flag specifies a condition which will cause an exception to be raised. The flags are listed in {{D3D11_RAISE_FLAG}}. A default value of 0 means there are no flags. + int ID3D11Device::GetExceptionMode() + + + + Get the imediate attached to this Device. + + + + + Gets a value indicating whether the current device is using the reference rasterizer. + + + + + Gets the feature level of the hardware device. + + + {{Feature levels}} determine the capabilities of your device. + + D3D_FEATURE_LEVEL ID3D11Device::GetFeatureLevel() + + + + Get the flags used during the call to create the device with . + + int ID3D11Device::GetCreationFlags() + + + + Get the reason why the device was removed. + + HRESULT ID3D11Device::GetDeviceRemovedReason() + + + + Get the exception-mode flags. + + + An exception-mode flag is used to elevate an error condition to a non-continuable exception. + + int ID3D11Device::GetExceptionMode() + + + + The ID3D11DeviceContext interface represents a device context which generates rendering commands. + + ID3D11DeviceContext + + + + Constructs a new deferred context . + + The device with which to associate the state object. + The newly created object. + + + + Create a command list and record graphics commands into it. + + A flag indicating whether the immediate context state is saved (prior) and restored (after) the execution of a command list. + The created command list containing the queued rendering commands. + + + + Gets data from the GPU asynchronously. + + The asynchronous data provider. + The data retrieved from the GPU. + + + + Gets data from the GPU asynchronously. + + The asynchronous data provider. + The data retrieved from the GPU. + + + + Gets data from the GPU asynchronously. + + The asynchronous data provider. + Flags specifying how the command should operate. + The data retrieved from the GPU. + + + + Gets data from the GPU asynchronously. + + The asynchronous data provider. + Flags specifying how the command should operate. + The data retrieved from the GPU. + + + + Get the rendering predicate state. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + a boolean to fill with the predicate comparison value. FALSE upon device creation. + a reference to a predicate (see ). + void ID3D11Device::GetPredication([Out, Optional] ID3D10Predicate** ppPredicate,[Out, Optional] BOOL* pPredicateValue) + + + + Copy the entire contents of the source resource to the destination resource using the GPU. + + + This method is unusual in that it causes the GPU to perform the copy operation (similar to a memcpy by the CPU). As a result, it has a few restrictions designed for improving performance. For instance, the source and destination resources: Must be different resources. Must be the same type. Must have identical dimensions (including width, height, depth, and size as appropriate). Will only be copied. CopyResource does not support any stretch, color key, blend, or format conversions. Must have compatible DXGI formats, which means the formats must be identical or at least from the same type group. For example, a DXGI_FORMAT_R32G32B32_FLOAT texture can be copied to an DXGI_FORMAT_R32G32B32_UINT texture since both of these formats are in the DXGI_FORMAT_R32G32B32_TYPELESS group. Might not be currently mapped. You cannot use an {{Immutable}} resource as a destination. You can use a {{depth-stencil}} resource as either a source or a destination. Resources created with multisampling capability (see ) can be used as source and destination only if both source and destination have identical multisampled count and quality. If source and destination differ in multisampled count and quality or if one is multisampled and the other is not multisampled the call to ID3D11DeviceContext::CopyResource fails. The method is an asynchronous call which may be added to the command-buffer queue. This attempts to remove pipeline stalls that may occur when copying data. An application that only needs to copy a portion of the data in a resource should use instead. + + A reference to the source resource (see ). + A reference to the destination resource (see ). + void ID3D11DeviceContext::CopyResource([In] ID3D11Resource* pDstResource,[In] ID3D11Resource* pSrcResource) + + + + Copy a region from a source resource to a destination resource. + + + The source box must be within the size of the source resource. The destination offsets, (x, y, and z) allow the source box to be offset when writing into the destination resource; however, the dimensions of the source box and the offsets must be within the size of the resource. If the resources are buffers, all coordinates are in bytes; if the resources are textures, all coordinates are in texels. {{D3D11CalcSubresource}} is a helper function for calculating subresource indexes. CopySubresourceRegion performs the copy on the GPU (similar to a memcpy by the CPU). As a consequence, the source and destination resources: Must be different subresources (although they can be from the same resource). Must be the same type. Must have compatible DXGI formats (identical or from the same type group). For example, a DXGI_FORMAT_R32G32B32_FLOAT texture can be copied to an DXGI_FORMAT_R32G32B32_UINT texture since both of these formats are in the DXGI_FORMAT_R32G32B32_TYPELESS group. May not be currently mapped. CopySubresourceRegion only supports copy; it does not support any stretch, color key, blend, or format conversions. An application that needs to copy an entire resource should use instead. CopySubresourceRegion is an asynchronous call which may be added to the command-buffer queue, this attempts to remove pipeline stalls that may occur when copying data. See performance considerations for more details. Note??If you use CopySubresourceRegion with a depth-stencil buffer or a multisampled resource, you must copy the whole subresource. In this situation, you must pass 0 to the DstX, DstY, and DstZ parameters and NULL to the pSrcBox parameter. In addition, source and destination resources, which are represented by the pSrcResource and pDstResource parameters, should have identical sample count values. Example The following code snippet copies a box (located at (120,100),(200,220)) from a source texture into a reqion (10,20),(90,140) in a destination texture. + D3D11_BOX sourceRegion; + sourceRegion.left = 120; + sourceRegion.right = 200; + sourceRegion.top = 100; + sourceRegion.bottom = 220; + sourceRegion.front = 0; + sourceRegion.back = 1; pd3dDeviceContext->CopySubresourceRegion( pDestTexture, 0, 10, 20, 0, pSourceTexture, 0, &sourceRegion ); + + Notice, that for a 2D texture, front and back are set to 0 and 1 respectively. + + A reference to the source resource (see ). + Source subresource index. + A reference to a 3D box (see ) that defines the source subresources that can be copied. If NULL, the entire source subresource is copied. The box must fit within the source resource. + A reference to the destination resource (see ). + Destination subresource index. + The x-coordinate of the upper left corner of the destination region. + The y-coordinate of the upper left corner of the destination region. For a 1D subresource, this must be zero. + The z-coordinate of the upper left corner of the destination region. For a 1D or 2D subresource, this must be zero. + void ID3D11DeviceContext::CopySubresourceRegion([In] ID3D11Resource* pDstResource,[In] int DstSubresource,[In] int DstX,[In] int DstY,[In] int DstZ,[In] ID3D11Resource* pSrcResource,[In] int SrcSubresource,[In, Optional] const D3D11_BOX* pSrcBox) + + + + Copy a multisampled resource into a non-multisampled resource. + + + This API is most useful when re-using the resulting rendertarget of one render pass as an input to a second render pass. The source and destination resources must be the same resource type and have the same dimensions. In addition, they must have compatible formats. There are three scenarios for this: ScenarioRequirements Source and destination are prestructured and typedBoth the source and destination must have identical formats and that format must be specified in the Format parameter. One resource is prestructured and typed and the other is prestructured and typelessThe typed resource must have a format that is compatible with the typeless resource (i.e. the typed resource is DXGI_FORMAT_R32_FLOAT and the typeless resource is DXGI_FORMAT_R32_TYPELESS). The format of the typed resource must be specified in the Format parameter. Source and destination are prestructured and typelessBoth the source and desintation must have the same typeless format (i.e. both must have DXGI_FORMAT_R32_TYPELESS), and the Format parameter must specify a format that is compatible with the source and destination (i.e. if both are DXGI_FORMAT_R32_TYPELESS then DXGI_FORMAT_R32_FLOAT could be specified in the Format parameter). For example, given the DXGI_FORMAT_R16G16B16A16_TYPELESS format: The source (or dest) format could be DXGI_FORMAT_R16G16B16A16_UNORM The dest (or source) format could be DXGI_FORMAT_R16G16B16A16_FLOAT ? + + Source resource. Must be multisampled. + >The source subresource of the source resource. + Destination resource. Must be a created with the flag and be single-sampled. See . + A zero-based index, that identifies the destination subresource. Use {{D3D11CalcSubresource}} to calculate the index. + A that indicates how the multisampled resource will be resolved to a single-sampled resource. See remarks. + void ID3D11DeviceContext::ResolveSubresource([In] ID3D11Resource* pDstResource,[In] int DstSubresource,[In] ID3D11Resource* pSrcResource,[In] int SrcSubresource,[In] DXGI_FORMAT Format) + + + + Maps a GPU resource into CPU-accessible memory. + + The resource to map. + Index of the subresource to map. + Size, in bytes, of the data to retrieve. + Specifies the CPU's read and write permissions for the resource. + Flags that specify what the CPU should do when the GPU is busy. + The mapped resource data. + + + + Copies data from the CPU to to a non-mappable subresource region. + + The source data. + The destination resource. + The destination subresource. + + + + Copies data from the CPU to to a non-mappable subresource region. + + The source data. + The destination resource. + The destination subresource. + The destination region within the resource. + + + + Initializes a new instance of the class. + + The native pointer. + + + Update nested inner interfaces pointer + + + + Draw indexed, non-instanced primitives. + + + A draw API submits work to the rendering pipeline. If the sum of both indices is negative, the result of the function call is undefined. + + Number of indices to draw. + The location of the first index read by the GPU from the index buffer. + A value added to each index before reading a vertex from the vertex buffer. + void ID3D11DeviceContext::DrawIndexed([In] int IndexCount,[In] int StartIndexLocation,[In] int BaseVertexLocation) + + + + Draw non-indexed, non-instanced primitives. + + + A draw API submits work to the rendering pipeline. The vertex data for a draw call normally comes from a vertex buffer that is bound to the pipeline. However, you could also provide the vertex data from a shader that has vertex data marked with the SV_VertexId system-value semantic. + + Number of vertices to draw. + Index of the first vertex, which is usually an offset in a vertex buffer; it could also be used as the first vertex id generated for a shader parameter marked with the SV_TargetId system-value semantic. + void ID3D11DeviceContext::Draw([In] int VertexCount,[In] int StartVertexLocation) + + + + Get a reference to the data contained in a subresource, and deny the GPU access to that subresource. + + + If you call Map on a deferred context, you can only pass , D3D11_MAP_WRITE_NO_OVERWRITE, or both to the MapType parameter. Other D3D11_MAP-typed values are not supported for a deferred context. + + A reference to a interface. + Index number of the subresource. + Specifies the CPU's read and write permissions for a resource. For possible values, see . + {{Flag}} that specifies what the CPU should do when the GPU is busy. This flag is optional. + A reference to the mapped subresource (see ). + This method returns one of the following {{Direct3D 11 Return Codes}}. This method also returns DXGI_ERROR_WAS_STILL_DRAWING if MapFlags specifies D3D10_MAP_FLAG_DO_NOT_WAIT and the GPU is not yet finished with the resource. For more information about this error code, see . + HRESULT ID3D11DeviceContext::Map([In] ID3D11Resource* pResource,[In] int Subresource,[In] D3D11_MAP MapType,[In] D3D11_MAP_FLAG MapFlags,[Out] D3D11_MAPPED_SUBRESOURCE* pMappedResource) + + + + Invalidate the reference to a resource and re-enable the GPU's access to that resource. + + A reference to a interface. + A subresource to be unmapped. + void ID3D11DeviceContext::Unmap([In] ID3D11Resource* pResource,[In] int Subresource) + + + + Draw indexed, instanced primitives. + + + A draw API submits work to the rendering pipeline. Instancing may extend performance by reusing the same geometry to draw multiple objects in a scene. One example of instancing could be to draw the same object with different positions and colors. Indexing requires multiple vertex buffers: at least one for per-vertex data and a second buffer for per-instance data. + + Number of indices read from the index buffer for each instance. + Number of instances to draw. + The location of the first index read by the GPU from the index buffer. + A value added to each index before reading a vertex from the vertex buffer. + A value added to each index before reading per-instance data from a vertex buffer. + void ID3D11DeviceContext::DrawIndexedInstanced([In] int IndexCountPerInstance,[In] int InstanceCount,[In] int StartIndexLocation,[In] int BaseVertexLocation,[In] int StartInstanceLocation) + + + + Draw non-indexed, instanced primitives. + + + A draw API submits work to the rendering pipeline. Instancing may extend performance by reusing the same geometry to draw multiple objects in a scene. One example of instancing could be to draw the same object with different positions and colors. The vertex data for an instanced draw call normally comes from a vertex buffer that is bound to the pipeline. However, you could also provide the vertex data from a shader that has instanced data identified with a system-value semantic (SV_InstanceID). + + Number of vertices to draw. + Number of instances to draw. + Index of the first vertex. + A value added to each index before reading per-instance data from a vertex buffer. + void ID3D11DeviceContext::DrawInstanced([In] int VertexCountPerInstance,[In] int InstanceCount,[In] int StartVertexLocation,[In] int StartInstanceLocation) + + + + Mark the beginning of a series of commands. + + + Use to mark the ending of the series of commands. + + A reference to an interface. + void ID3D11DeviceContext::Begin([In] ID3D11Asynchronous* pAsync) + + + + Mark the end of a series of commands. + + + Use to mark the beginning of the series of commands. + + A reference to an interface. + void ID3D11DeviceContext::End([In] ID3D11Asynchronous* pAsync) + + + + Get data from the GPU asynchronously. + + + Queries in a deferred context are limited to predicated drawing. That is, you cannot call ID3D11DeviceContext::GetData on a deferred context to get data about a query; you can only call GetData on the immediate context to get data about a query. For predicated drawing, the results of a predication-type query are used by the GPU and not returned to an application. For more information about predication and predicated drawing, see {{D3D11DeviceContext::SetPredication}}. + + A reference to an interface. + void Address of memory that will receive the data. If NULL, GetData will be used only to check status. The type of data output depends on the type of asynchronous interface. + Size of the data to retrieve or 0. Must be 0 when pData is NULL. + Optional flags. Can be 0 or any combination of the flags enumerated by . + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11DeviceContext::GetData([In] ID3D11Asynchronous* pAsync,[Out, Buffer, Optional] void* pData,[In] int DataSize,[In] D3D11_ASYNC_GETDATA_FLAG GetDataFlags) + + + + Set a rendering predicate. + + + The predicate must be in the "issued" or "signaled" state to be used for predication. While the predicate is set for predication, calls to and are invalid. This method is used to denote that subsequent rendering and resource manipulation commands are not actually performed if the resulting Predicate data of the Predicate is equal to the PredicateValue. However, some Predicates are only hints, so they may not actually prevent operations from being performed. The primary usefulness of Predication is to allow an application to issue graphics commands without taking the performance hit of spinning, waiting for to return. So, Predication can occur while ID3D11DeviceContext::GetData returns S_FALSE. Another way to think of it: an application can also use Predication as a fallback, if it is possible that ID3D11DeviceContext::GetData returns S_FALSE. If ID3D11DeviceContext::GetData returns S_OK, the application can skip calling the graphics commands manually with it's own application logic. + + Pointer to a predicate (see ). A NULL value indicates "no" predication; in this case, the value of PredicateValue is irrelevent but will be preserved for . + If TRUE, rendering will be affected by when the predicate's conditions are met. If FALSE, rendering will be affected when the conditions are not met. + void ID3D11DeviceContext::SetPredication([In, Optional] ID3D11Predicate* pPredicate,[In] BOOL PredicateValue) + + + + Draw geometry of an unknown size. + + + A draw API submits work to the rendering pipeline. This API submits work of an unknown size that was processed by the input assembler, vertex shader, and stream-output stages; the work may or may not have gone through the geometry-shader stage. After data has been streamed out to stream-output stage buffers, those buffers can be again bound to the Input Assembler stage at input slot 0 and DrawAuto will draw them without the application needing to know the amount of data that was written to the buffers. A measurement of the amount of data written to the SO stage buffers is maintained internally when the data is streamed out. This means that the CPU does not need to fetch the measurement before re-binding the data that was streamed as input data. Although this amount is tracked internally, it is still the responsibility of applications to use input layouts to describe the format of the data in the SO stage buffers so that the layouts are available when the buffers are again bound to the input assembler. The following diagram shows the DrawAuto process. ? Diagram of DrawAuto as data moves through several stages to a buffer and then back to the Input Assembler stage ? Calling DrawAuto does not change the state of the streaming-output buffers that were bound again as inputs. DrawAuto only works when drawing with one input buffer bound as an input to the IA stage at slot 0. Applications must create the SO buffer resource with both binding flags, and D3D11_BIND_STREAM_OUTPUT. This API does not support indexing or instancing. If an application needs to retrieve the size of the streaming-output buffer, it can query for statistics on streaming output by using . + + void ID3D11DeviceContext::DrawAuto() + + + + Draw indexed, instanced, GPU-generated primitives. + + + When an application creates a buffer that is associated with the interface that pBufferForArgs points to, the application must set the flag in the MiscFlags member of the structure that describes the buffer. To create the buffer, the application calls the method and in this call passes a reference to D3D11_BUFFER_DESC in the pDesc parameter. + + A reference to an , which is a buffer containing the GPU generated primitives. + Offset in pBufferForArgs to the start of the GPU generated primitives. + void ID3D11DeviceContext::DrawIndexedInstancedIndirect([In] ID3D11Buffer* pBufferForArgs,[In] int AlignedByteOffsetForArgs) + + + + Draw instanced, GPU-generated primitives. + + + When an application creates a buffer that is associated with the interface that pBufferForArgs points to, the application must set the flag in the MiscFlags member of the structure that describes the buffer. To create the buffer, the application calls the method and in this call passes a reference to D3D11_BUFFER_DESC in the pDesc parameter. + + A reference to an , which is a buffer containing the GPU generated primitives. + Offset in pBufferForArgs to the start of the GPU generated primitives. + void ID3D11DeviceContext::DrawInstancedIndirect([In] ID3D11Buffer* pBufferForArgs,[In] int AlignedByteOffsetForArgs) + + + + Execute a command list from a thread group. + + + A compute shader can be run on many threads in parallel, within a thread group. Index a particular thread, within a thread group using a 3D vector given by (x,y,z). In the following illustration, assume a thread group with 50 threads where the size of the group is given by (5,5,2). A single thread is identified from a thread group with 50 threads in it, using the vector (4,1,1). ? Illustration of a single thread within a thread group of 50 threads ? The following illustration shows the relationship between the parameters passed to ID3D11DeviceContext::Dispatch, Dispatch(5,3,2), the values specified in the {{numthreads}} attribute, numthreads(10,8,3), and values that will passed to the compute shader for the thread-related system values + ({{SV_GroupIndex}},{{SV_DispatchThreadID}},{{SV_GroupThreadID}},{{SV_GroupID}}). ? Illustration of the relationship between Dispatch, thread groups, and threads ? + + The number of groups dispatched in the x direction. ThreadGroupCountX must be less than 64k. + The number of groups dispatched in the y direction. ThreadGroupCountY must be less than 64k. + The number of groups dispatched in the z direction. ThreadGroupCountZ must be less than 64k. In feature level 10 the value for ThreadGroupCountZ must be 1. + void ID3D11DeviceContext::Dispatch([In] int ThreadGroupCountX,[In] int ThreadGroupCountY,[In] int ThreadGroupCountZ) + + + + Execute a command list to draw GPU-generated primitives over one or more thread groups. + + + When an application creates a buffer that is associated with the interface that pBufferForArgs points to, the application must set the flag in the MiscFlags member of the structure that describes the buffer. To create the buffer, the application calls the method and in this call passes a reference to D3D11_BUFFER_DESC in the pDesc parameter. + + A reference to an , which must be loaded with data that matches the argument list for . + A byte-aligned offset between the start of the buffer and the arguments. + void ID3D11DeviceContext::DispatchIndirect([In] ID3D11Buffer* pBufferForArgs,[In] int AlignedByteOffsetForArgs) + + + + Copy a region from a source resource to a destination resource. + + + The source box must be within the size of the source resource. The destination offsets, (x, y, and z) allow the source box to be offset when writing into the destination resource; however, the dimensions of the source box and the offsets must be within the size of the resource. If the resources are buffers, all coordinates are in bytes; if the resources are textures, all coordinates are in texels. {{D3D11CalcSubresource}} is a helper function for calculating subresource indexes. CopySubresourceRegion performs the copy on the GPU (similar to a memcpy by the CPU). As a consequence, the source and destination resources: Must be different subresources (although they can be from the same resource). Must be the same type. Must have compatible DXGI formats (identical or from the same type group). For example, a DXGI_FORMAT_R32G32B32_FLOAT texture can be copied to an DXGI_FORMAT_R32G32B32_UINT texture since both of these formats are in the DXGI_FORMAT_R32G32B32_TYPELESS group. May not be currently mapped. CopySubresourceRegion only supports copy; it does not support any stretch, color key, blend, or format conversions. An application that needs to copy an entire resource should use instead. CopySubresourceRegion is an asynchronous call which may be added to the command-buffer queue, this attempts to remove pipeline stalls that may occur when copying data. See performance considerations for more details. Note??If you use CopySubresourceRegion with a depth-stencil buffer or a multisampled resource, you must copy the whole subresource. In this situation, you must pass 0 to the DstX, DstY, and DstZ parameters and NULL to the pSrcBox parameter. In addition, source and destination resources, which are represented by the pSrcResource and pDstResource parameters, should have identical sample count values. Example The following code snippet copies a box (located at (120,100),(200,220)) from a source texture into a reqion (10,20),(90,140) in a destination texture. + D3D11_BOX sourceRegion; + sourceRegion.left = 120; + sourceRegion.right = 200; + sourceRegion.top = 100; + sourceRegion.bottom = 220; + sourceRegion.front = 0; + sourceRegion.back = 1; pd3dDeviceContext->CopySubresourceRegion( pDestTexture, 0, 10, 20, 0, pSourceTexture, 0, &sourceRegion ); + + Notice, that for a 2D texture, front and back are set to 0 and 1 respectively. + + A reference to the destination resource (see ). + Destination subresource index. + The x-coordinate of the upper left corner of the destination region. + The y-coordinate of the upper left corner of the destination region. For a 1D subresource, this must be zero. + The z-coordinate of the upper left corner of the destination region. For a 1D or 2D subresource, this must be zero. + A reference to the source resource (see ). + Source subresource index. + A reference to a 3D box (see ) that defines the source subresources that can be copied. If NULL, the entire source subresource is copied. The box must fit within the source resource. + void ID3D11DeviceContext::CopySubresourceRegion([In] ID3D11Resource* pDstResource,[In] int DstSubresource,[In] int DstX,[In] int DstY,[In] int DstZ,[In] ID3D11Resource* pSrcResource,[In] int SrcSubresource,[In, Optional] const D3D11_BOX* pSrcBox) + + + + Copy the entire contents of the source resource to the destination resource using the GPU. + + + This method is unusual in that it causes the GPU to perform the copy operation (similar to a memcpy by the CPU). As a result, it has a few restrictions designed for improving performance. For instance, the source and destination resources: Must be different resources. Must be the same type. Must have identical dimensions (including width, height, depth, and size as appropriate). Will only be copied. CopyResource does not support any stretch, color key, blend, or format conversions. Must have compatible DXGI formats, which means the formats must be identical or at least from the same type group. For example, a DXGI_FORMAT_R32G32B32_FLOAT texture can be copied to an DXGI_FORMAT_R32G32B32_UINT texture since both of these formats are in the DXGI_FORMAT_R32G32B32_TYPELESS group. Might not be currently mapped. You cannot use an {{Immutable}} resource as a destination. You can use a {{depth-stencil}} resource as either a source or a destination. Resources created with multisampling capability (see ) can be used as source and destination only if both source and destination have identical multisampled count and quality. If source and destination differ in multisampled count and quality or if one is multisampled and the other is not multisampled the call to ID3D11DeviceContext::CopyResource fails. The method is an asynchronous call which may be added to the command-buffer queue. This attempts to remove pipeline stalls that may occur when copying data. An application that only needs to copy a portion of the data in a resource should use instead. + + A reference to the destination resource (see ). + A reference to the source resource (see ). + void ID3D11DeviceContext::CopyResource([In] ID3D11Resource* pDstResource,[In] ID3D11Resource* pSrcResource) + + + + The CPU copies data from memory to a subresource created in non-mappable memory. + + + For a shader-constant buffer; set pDstBox to NULL. It is not possible to use this method to partially update a shader-constant buffer. A resource cannot be used as a destination if: the resource is created with {{immutable}} usage. the resource is created as a depth-stencil resource. the resource is created with multisampling capability (see ). When UpdateSubresource returns, the application is free to change or even free the data pointed to by pSrcData because the method has already copied/snapped away the original contents. The performance of UpdateSubresource depends on whether or not there is contention for the destination resource. For example, contention for a vertex buffer resource occurs when the application executes a Draw call and later calls UpdateSubresource on the same vertex buffer before the Draw call is actually executed by the GPU. When there is contention for the resource, UpdateSubresource will perform 2 copies of the source data. First, the data is copied by the CPU to a temporary storage space accessible by the command buffer. This copy happens before the method returns. A second copy is then performed by the GPU to copy the source data into non-mappable memory. This second copy happens asynchronously because it is executed by GPU when the command buffer is flushed. When there is no resource contention, the behavior of UpdateSubresource is dependent on which is faster (from the CPU's perspective): copying the data to the command buffer and then having a second copy execute when the command buffer is flushed, or having the CPU copy the data to the final resource location. This is dependent on the architecture of the underlying system. To better understand the source row pitch and source depth pitch parameters, the following illustration shows a 3D volume texture. ? Illustration of a 3D volume texture ? Each block in this visual represents an element of data, and the size of each element is dependent on the resource's format. For example, if the resource format is DXGI_FORMAT_R32G32B32A32_FLOAT, the size of each element would be 128 bits, or 16 bytes. This 3D volume texture has a width of two, a height of three, and a depth of four. To calculate the source row pitch and source depth pitch for a given resource, use the following formulas: Source Row Pitch = [size of one element in bytes] * [number of elements in one row] Source Depth Pitch = [Source Row Pitch] * [number of rows (height)] In the case of this example 3D volume texture where the size of each element is 16 bytes, the formulas are as follows: Source Row Pitch = 16 * 2 = 32 Source Depth Pitch = 16 * 2 * 3 = 96 The following illustration shows the resource as it is laid out in memory. ? Illustration of a 3D volume texture laid out in memory ? For example, the following code snippet shows how to specify a destination region in a 2D texture. Assume the destination texture is 512x512 and the operation will copy the data pointed to by pData to [(120,100)..(200,220)] in the destination texture. Also assume that rowPitch has been initialized with the proper value (as explained above). front and back are set to 0 and 1 respectively, because by having front equal to back, the box is technically empty. + D3D11_BOX destRegion; + destRegion.left = 120; + destRegion.right = 200; + destRegion.top = 100; + destRegion.bottom = 220; + destRegion.front = 0; + destRegion.back = 1; pd3dDeviceContext->UpdateSubresource( pDestTexture, 0, &destRegion, pData, rowPitch, 0 ); + + The 1D case is similar. The following snippet shows how to specify a destination region in a 1D texture. Use the same assumptions as above, except that the texture is 512 in length. + D3D11_BOX destRegion; + destRegion.left = 120 + destRegion.right = 200; + destRegion.top = 0; + destRegion.bottom = 1; + destRegion.front = 0; + destRegion.back = 1; pd3dDeviceContext->UpdateSubresource( pDestTexture, 0, &destRegion, pData, rowPitch, 0 ); + + Calling UpdateSubresource on a Deferred Context If your application calls UpdateSubresource on a deferred context with a destination box?to which pDstBox points?that has a non-(0,0,0) offset, where the driver does not support command lists, UpdateSubresource inappropriately applies that destination-box offset to the pSrcData parameter. To work around this behavior, use the following code: + HRESULT UpdateSubresource_Workaround( ID3D11Device *pDevice, ID3D11DeviceContext *pDeviceContext, ID3D11Resource *pDstResource, UINT dstSubresource, const D3D11_BOX *pDstBox, const void *pSrcData, UINT srcBytesPerElement, UINT srcRowPitch, UINT srcDepthPitch, bool* pDidWorkAround ) + { HRESULT hr = S_OK; bool needWorkaround = false; D3D11_DEVICE_CONTEXT_TYPE contextType = pDeviceContext->GetType(); if( pDstBox && (D3D11_DEVICE_CONTEXT_DEFERRED == contextType) ) { D3D11_FEATURE_DATA_THREADING threadingCaps = { FALSE, FALSE }; hr = pDevice->CheckFeatureSupport( D3D11_FEATURE_THREADING, &threadingCaps, sizeof(threadingCaps) ); if( SUCCEEDED(hr) ) { if( !threadingCaps.DriverCommandLists ) { needWorkaround = true; } } } const void* pAdjustedSrcData = pSrcData; if( needWorkaround ) { D3D11_BOX alignedBox = *pDstBox; // convert from pixels to blocks if( m_bBC ) { alignedBox.left /= 4; alignedBox.right /= 4; alignedBox.top /= 4; alignedBox.bottom /= 4; } pAdjustedSrcData = ((const BYTE*)pSrcData) - (alignedBox.front * srcDepthPitch) - (alignedBox.top * srcRowPitch) - (alignedBox.left * srcBytesPerElement); } pDeviceContext->UpdateSubresource( pDstResource, dstSubresource, pDstBox, pAdjustedSrcData, srcRowPitch, srcDepthPitch ); if( pDidWorkAround ) { *pDidWorkAround = needWorkaround; } return hr; + } + + + + A reference to the destination resource (see ). + A zero-based index, that identifies the destination subresource. See {{D3D11CalcSubresource}} for more details. + A reference to a box that defines the portion of the destination subresource to copy the resource data into. Coordinates are in bytes for buffers and in texels for textures. If NULL, the data is written to the destination subresource with no offset. The dimensions of the source must fit the destination (see ). + void A reference to the source data in memory. + The size of one row of the source data. + The size of one depth slice of source data. + void ID3D11DeviceContext::UpdateSubresource([In] ID3D11Resource* pDstResource,[In] int DstSubresource,[In, Optional] const D3D11_BOX* pDstBox,[In] const void* pSrcData,[In] int SrcRowPitch,[In] int SrcDepthPitch) + + + + Copies data from a buffer holding variable length data. + + Pointer to . This can be any buffer resource that other copy commands, such as or , are able to write to. + Offset from the start of pDstBuffer to write 32-bit UINT structure (vertex) count from pSrcView. + Pointer to an of a Structured Buffer resource created with either or D3D11_BUFFER_UAV_FLAG_COUNTER specified when the UAV was created. These types of resources have hidden counters tracking "how many" records have been written. + void ID3D11DeviceContext::CopyStructureCount([In] ID3D11Buffer* pDstBuffer,[In] int DstAlignedByteOffset,[In] ID3D11UnorderedAccessView* pSrcView) + + + + Set all the elements in a render target to one value. + + + Applications that wish to clear a render target to a specific integer value bit pattern should render a screen-aligned quad instead of using this method. The reason for this is because this method accepts as input a floating point value, which may not have the same bit pattern as the original integer. Differences between Direct3D 9 and Direct3D 11/10: Unlike Direct3D 9, the full extent of the resource view is always cleared. Viewport and scissor settings are not applied. ? + + Pointer to the rendertarget. + A 4-component array that represents the color to fill the render target with. + void ID3D11DeviceContext::ClearRenderTargetView([In] ID3D11RenderTargetView* pRenderTargetView,[In] const SHARPDX_COLOR4* ColorRGBA) + + + + Clears an {{unordered access}} resource with bit-precise values. + + + This API copies the lower ni bits from each array element i to the corresponding channel, where ni is the number of bits in the ith channel of the resource format (for example, R8G8B8_FLOAT has 8 bits for the first 3 channels). This works on any UAV with no format conversion. For a raw or structured buffer view, only the first array element value is used. + + The to clear. + Values to copy to corresponding channels, see remarks. + void ID3D11DeviceContext::ClearUnorderedAccessViewUint([In] ID3D11UnorderedAccessView* pUnorderedAccessView,[In] const int Values[4]) + + + + Clears an {{unordered access}} resource with a float value. + + + This API works on FLOAT, UNORM, and SNORM unordered access views (UAVs), with format conversion from FLOAT to *NORM where appropriate. On other UAVs, the operation is invalid and the call will not reach the driver. + + The to clear. + FLOATS Values to copy to corresponding channels, see remarks. + void ID3D11DeviceContext::ClearUnorderedAccessViewFloat([In] ID3D11UnorderedAccessView* pUnorderedAccessView,[In] const float Values[4]) + + + + Clears the depth-stencil resource. + + + Differences between Direct3D 9 and Direct3D 11/10: Unlike Direct3D 9, the full extent of the resource view is always cleared. Viewport and scissor settings are not applied. ? + + Pointer to the depth stencil to be cleared. + Identify the type of data to clear (see ). + Clear the depth buffer with this value. This value will be clamped between 0 and 1. + UINT8 Clear the stencil buffer with this value. + void ID3D11DeviceContext::ClearDepthStencilView([In] ID3D11DepthStencilView* pDepthStencilView,[In] D3D11_CLEAR_FLAG ClearFlags,[In] float Depth,[In] byte Stencil) + + + + Generate mipmaps for the given shader resource. + + + GenerateMips may be called on any shader-resource view in order to generate the lower mipmap levels. GenerateMips uses the largest mipmap level of the view to recursively generate the lower levels of the mip, stopping with the smallest level specified by the view. If the base resource was not created with and , this call has no effect. All video adapters support generating mipmaps if you are using any of the following formats: + DXGI_FORMAT_A8_UNORM + DXGI_FORMAT_R10G10B10A2_UNORM + DXGI_FORMAT_R11G11B10_FLOAT + DXGI_FORMAT_R16_FLOAT + DXGI_FORMAT_R16_SNORM + DXGI_FORMAT_R16_UNORM + DXGI_FORMAT_R16G16_FLOAT + DXGI_FORMAT_R16G16_SNORM + DXGI_FORMAT_R16G16_UNORM + DXGI_FORMAT_R16G16B16A16_FLOAT + DXGI_FORMAT_R16G16B16A16_SNORM + DXGI_FORMAT_R16G16B16A16_UNORM + DXGI_FORMAT_R32_FLOAT + DXGI_FORMAT_R32G32_FLOAT + DXGI_FORMAT_R32G32B32A32_FLOAT + DXGI_FORMAT_R8_SNORM + DXGI_FORMAT_R8_UNORM + DXGI_FORMAT_R8G8_SNORM + DXGI_FORMAT_R8G8_UNORM + DXGI_FORMAT_R8G8B8A8_SNORM + DXGI_FORMAT_R8G8B8A8_UNORM + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB + + Some video adapters support generating mipmaps if you are using this format: + DXGI_FORMAT_R32G32B32_FLOAT + + For all other unsupported formats, this method will silently fail. + + Pointer to an interface that represents the shader resource. + void ID3D11DeviceContext::GenerateMips([In] ID3D11ShaderResourceView* pShaderResourceView) + + + + Sets the minimum level-of-detail (LOD) for a resource. + + + To use a resource with SetResourceMinLOD, you must set the flag when you create that resource. For Direct3D 10 and Direct3D 10.1, when sampling from a texture resource in a shader, the sampler can define a minimum LOD clamp to force sampling from less detailed mip levels. For Direct3D 11, this functionality is extended from the sampler to the entire resource. Therefore, the application can specify the highest-resolution mip level of a resource that is available for access. This restricts the set of mip levels that are required to be resident in GPU memory, thereby saving memory. The set of mip levels resident per-resource in GPU memory can be specified by the user. Minimum LOD affects all of the resident mip levels. Therefore, only the resident mip levels can be updated and read from. All methods that access texture resources must adhere to minimum LOD clamps. Empty-set accesses are handled as out-of-bounds cases. + + A reference to an that represents the resource. + float The level-of-detail, which ranges between 0 and the maximum number of mipmap levels of the resource. For example, the maximum number of mipmap levels of a 1D texture is specified in the MipLevels member of the structure. + void ID3D11DeviceContext::SetResourceMinLOD([In] ID3D11Resource* pResource,[None] float MinLOD) + + + + Gets the minimum level-of-detail (LOD). + + A reference to an which represents the resource. + float Returns the minimum LOD. + float ID3D11DeviceContext::GetResourceMinLOD([In] ID3D11Resource* pResource) + + + + Copy a multisampled resource into a non-multisampled resource. + + + This API is most useful when re-using the resulting rendertarget of one render pass as an input to a second render pass. The source and destination resources must be the same resource type and have the same dimensions. In addition, they must have compatible formats. There are three scenarios for this: ScenarioRequirements Source and destination are prestructured and typedBoth the source and destination must have identical formats and that format must be specified in the Format parameter. One resource is prestructured and typed and the other is prestructured and typelessThe typed resource must have a format that is compatible with the typeless resource (i.e. the typed resource is DXGI_FORMAT_R32_FLOAT and the typeless resource is DXGI_FORMAT_R32_TYPELESS). The format of the typed resource must be specified in the Format parameter. Source and destination are prestructured and typelessBoth the source and desintation must have the same typeless format (i.e. both must have DXGI_FORMAT_R32_TYPELESS), and the Format parameter must specify a format that is compatible with the source and destination (i.e. if both are DXGI_FORMAT_R32_TYPELESS then DXGI_FORMAT_R32_FLOAT could be specified in the Format parameter). For example, given the DXGI_FORMAT_R16G16B16A16_TYPELESS format: The source (or dest) format could be DXGI_FORMAT_R16G16B16A16_UNORM The dest (or source) format could be DXGI_FORMAT_R16G16B16A16_FLOAT ? + + Destination resource. Must be a created with the flag and be single-sampled. See . + A zero-based index, that identifies the destination subresource. Use {{D3D11CalcSubresource}} to calculate the index. + Source resource. Must be multisampled. + >The source subresource of the source resource. + A that indicates how the multisampled resource will be resolved to a single-sampled resource. See remarks. + void ID3D11DeviceContext::ResolveSubresource([In] ID3D11Resource* pDstResource,[In] int DstSubresource,[In] ID3D11Resource* pSrcResource,[In] int SrcSubresource,[In] DXGI_FORMAT Format) + + + + Queues commands from a command list onto a device. + + + Use this method to play back a command list that was recorded by a deferred context on any thread. This method performs some runtime validation related to queries. Queries that are begun in a device context cannot be manipulated indirectly by executing a command list (that is, Begin or End was invoked against the same query by the deferred context which generated the command list). If such a condition occurs, the ExecuteCommandList method does not execute the command list. However, the state of the device context is still maintained, as would be expected ( is performed, unless the application indicates to preserve the device context state). + + A reference to an interface that encapsulates a command list. + A Boolean flag that determines whether the immediate context state is saved prior to and restored after the execution of a command list. Use TRUE to indicate that the runtime needs to save and restore the state. Use FALSE to indicate that no state shall be saved or restored, which causes the immediate context to return to its default state after the command list executes. Applications should typically use FALSE unless they will restore the state to be nearly equivalent to the state that the runtime would restore if TRUE were passed. When applications use FALSE, they can avoid unnecessary and inefficient state transitions. + void ID3D11DeviceContext::ExecuteCommandList([In] ID3D11CommandList* pCommandList,[None] BOOL RestoreContextState) + + + + Get the rendering predicate state. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Address of a boolean to fill with the predicate comparison value. FALSE upon device creation. + void ID3D11DeviceContext::GetPredication([Out, Optional] ID3D11Predicate** ppPredicate,[Out, Optional] BOOL* pPredicateValue) + + + + Restore all default settings. + + + This method resets any device context to the default settings. This sets all input/output resource slots, shaders, input layouts, predications, scissor rectangles, depth-stencil state, rasterizer state, blend state, sampler state, and viewports to NULL. The primitive topology is set to UNDEFINED. For a scenario where you would like to clear a list of commands recorded so far, call and throw away the resulting . + + void ID3D11DeviceContext::ClearState() + + + + Send queued-up commands in the command buffer to the GPU. + + + Most applications will not need to call this method. Calling this method when not necessary will incur a performance penalty. Each call to Flush incurs a significant amount of overhead. When Direct3D state-setting, present, or draw commands are called by an application, those commands are queued into an internal command buffer. Flush sends those commands to the GPU for processing. Normally, these commands are sent to the GPU automatically whenever Direct3D determines that they need to be, such as when the command buffer is full or when mapping a resource. Flush will send the commands manually. Flush should be used when the CPU waits for an arbitrary amount of time (such as when calling {{Sleep}}). Because Flush operates asynchronously, it can return either before or after the GPU finishes executing the queued graphics commands. However, the graphics commands will eventually always complete. You can call the method with the value to create an event query; you can then use that event query in a call to the method to determine when the GPU is finished processing the graphics commands. + Direct3D11 defers the destruction of objects, an application cannot rely upon objects immediately being destroyed. Calling Flush will destroy any objects whose destruction has been deferred. If an application requires synchronous destruction of an object the application should release all its references, call , and then call Flush. + + void ID3D11DeviceContext::Flush() + + + + Gets the type of {{device context}}. + + A member of that indicates the type of device context. + D3D11_DEVICE_CONTEXT_TYPE ID3D11DeviceContext::GetType() + + + + Gets the initialization flags associated with the current deferred context. + + + The GetContextFlags method gets the flags that were supplied to the ContextFlags parameter of ; however, the context flag is reserved for future use. + + No documentation. + int ID3D11DeviceContext::GetContextFlags() + + + + Create a command list and record graphics commands into it. + + + Create a command list from a deferred context and record commands into it by calling FinishCommandList. Play back a command list with an immediate context by calling . Immediate context state is cleared before and after a command list is executed. A command list has no concept of inheritance. Each call to FinishCommandList will record only the state set since any previous call to FinishCommandList. For example, the state of a {{device context}} is its render state or pipeline state. To retrieve device context state, an application can call or . For more information about how to use FinishCommandList, see {{How to: Record a Command List}}. + + A Boolean flag that determines whether the runtime saves deferred context state before it executes FinishCommandList and restores it afterwards. Use TRUE to indicate that the runtime needs to save and restore the state. Use FALSE to indicate that the runtime will not save or restore any state. In this case, the deferred context will return to its default state after the call to FinishCommandList completes. Typically, use FALSE unless you restore the state to be nearly equivalent to the state that the runtime would restore if you passed TRUE. When you use FALSE, you can avoid unnecessary and inefficient state transitions. + Upon completion of the method, the passed reference to an interface reference is initialized with the recorded command list information. + Returns S_OK if successful; otherwise, returns one of the following: Returns DXGI_ERROR_DEVICE_REMOVED if the video card has been physically removed from the system, or a driver upgrade for the video card has occurred. If this error occurs, you should destroy and recreate the device. Returns DXGI_ERROR_INVALID_CALL if FinishCommandList cannot be called from the current context. See remarks. Returns E_OUTOFMEMORY if the application has exhausted available memory. + HRESULT ID3D11DeviceContext::FinishCommandList([None] BOOL RestoreDeferredContextState,[Out, Optional] ID3D11CommandList** ppCommandList) + + + Inner interface giving access to InputAssemblerStage methods. + + + Inner interface giving access to VertexShaderStage methods. + + + Inner interface giving access to PixelShaderStage methods. + + + Inner interface giving access to GeometryShaderStage methods. + + + Inner interface giving access to StreamOutputStage methods. + + + Inner interface giving access to DomainShaderStage methods. + + + Inner interface giving access to HullShaderStage methods. + + + Inner interface giving access to RasterizerStage methods. + + + Inner interface giving access to OutputMergerStage methods. + + + Inner interface giving access to ComputeShaderStage methods. + + + + Gets the type of {{device context}}. + + D3D11_DEVICE_CONTEXT_TYPE ID3D11DeviceContext::GetType() + + + + Gets the initialization flags associated with the current deferred context. + + + The GetContextFlags method gets the flags that were supplied to the ContextFlags parameter of ; however, the context flag is reserved for future use. + + int ID3D11DeviceContext::GetContextFlags() + + + Inner interface StreamOutputStage. + ID3D11DeviceContext + + + + Set the target output {{buffers}} for the {{StreamOutput}} stage, which enables/disables the pipeline to stream-out data. + + + Call ID3D10Device::SOSetTargets (before any draw calls) to stream data out; call SOSetTargets with NULL to stop streaming data out. For an example, see Exercise 01 from the GDC 2007 workshop, which sets the stream output rendertargets before calling draw methods in the RenderInstanceToStream function. An offset of -1 will cause the stream output buffer to be appended, continuing after the last location written to the buffer in a previous stream output pass. Calling this method using a buffer that is currently bound for writing will effectively bind NULL instead because a buffer cannot be bound as both an input and an output at the same time. The {{Debug Layer}} will generate a warning whenever a resource is prevented from being bound simultaneously as an input and an output, but this will not prevent invalid data from being used by the runtime. The method will not hold a reference to the interfaces passed in. For that reason, applications should be careful not to release an interface currently in use by the device. + + an array of output buffers (see ) to bind to the device. The buffers must have been created with the flag. + void SOSetTargets([In] int NumBuffers,[In, Buffer, Optional] const ID3D10Buffer** ppSOTargets,[In, Buffer, Optional] const int* pOffsets) + + + + Get the target output {{buffers}} for the {{StreamOutput}} stage of the pipeline. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Number of buffers to get. A maximum of four output buffers can be retrieved. + an array of output buffers (see ) to bind to the device. + void SOGetTargets([In] int NumBuffers,[Out, Buffer, Optional] ID3D10Buffer** ppSOTargets,[Out, Buffer, Optional] int* pOffsets) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set the target output buffers for the stream-output stage of the pipeline. + + + An offset of -1 will cause the stream output buffer to be appended, continuing after the last location written to the buffer in a previous stream output pass. Calling this method using a buffer that is currently bound for writing will effectively bind NULL instead because a buffer cannot be bound as both an input and an output at the same time. The debug layer will generate a warning whenever a resource is prevented from being bound simultaneously as an input and an output, but this will not prevent invalid data from being used by the runtime. The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + The number of buffer to bind to the device. A maximum of four output buffers can be set. If less than four are defined by the call, the remaining buffer slots are set to NULL. See Remarks. + The array of output buffers (see ) to bind to the device. The buffers must have been created with the flag. + Array of offsets to the output buffers from ppSOTargets, one offset for each buffer. The offset values must be in bytes. + void SOSetTargets([In] int NumBuffers,[In, Buffer, Optional] const ID3D11Buffer** ppSOTargets,[In, Buffer, Optional] const int* pOffsets) + + + + Get the target output buffers for the stream-output stage of the pipeline. + + + A maximum of four output buffers can be retrieved. The offsets to the output buffers pointed to in the returned ppSOTargets array may be assumed to be -1 (append), as defined for use in . Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Number of buffers to get. + An array of output buffers (see ) to be retrieved from the device. + void SOGetTargets([In] int NumBuffers,[Out, Buffer] ID3D11Buffer** ppSOTargets) + + + + Common Shader class. Provides a common set of methods for a Shader Stage. + TODO: check if usage of abstract is not introducing an unacceptable overhead... + + Type of the shader + + + + Initializes a new instance of the class. + + The pointer. + + + + Gets the shader currently assigned to the device. + + The shader (null if no shader is assigned). + + + + Gets the shader currently assigned to the device. + + An array that will be used to contain any class instances currently active. + The shader (null if no shader is assigned). + + + + Gets the constant buffers used by the shader stage. + + Index into the device's zero-based array from which to begin retrieving constant buffers. + Number of buffers to retrieve. + An array of constant buffers. + + + + Gets the sampler states used by the shader stage. + + Index into the device's zero-based array from which to begin retrieving samplers. + Number of samplers to retrieve. + An array of sampler states. + + + + Gets the shader resources used by the shader stage. + + Index into the device's zero-based array from which to begin retrieving shader resources. + Number of resources to retrieve. + An array of shader resources. + + + + Assigns a compute shader to the device. + + The shader to assign to the device. Assign null to disable the compute shader. + + + + Assigns a compute shader to the device. + + The shader to assign to the device. Assign null to disable the compute shader. + An array of class-instance interfaces. Each interface used by a shader must have a corresponding class instance or the shader will get disabled. + + + + Sets a single constant buffer to be used by the shader stage. + + Index into the device's zero-based array to which to set the constant buffer. + constant buffer to set + + + + Sets a single sampler to be used by the shader stage. + + Index into the device's zero-based array to which to set the sampler. + sampler state to set + + + + Sets a single shader resource to be used by the shader stage. + + Index into the device's zero-based array to which to set the resource. + Resource view to attach + + + + Get the shader resources. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + The number of resources to get from the device. Up to a maximum of 128 slots are available for shader resources (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to be returned by the device. + void PSGetShaderResources([In] UINT StartSlot,[In] UINT NumViews,[Out, Buffer] ID3D11ShaderResourceView** ppShaderResourceViews) + + + + Get an array of sampler states from the shader pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into a zero-based array to begin getting samplers from (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers to get from a device context. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Arry of sampler-state interface pointers (see ) to be returned by the device. + void PSGetSamplers([In] UINT StartSlot,[In] UINT NumSamplers,[Out, Buffer] ID3D11SamplerState** ppSamplers) + + + + Get the constant buffers used by the shader pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to retrieve (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffer interface pointers (see ) to be returned by the method. + void PSGetConstantBuffers([In] UINT StartSlot,[In] UINT NumBuffers,[Out, Buffer] ID3D11Buffer** ppConstantBuffers) + + + + Bind an array of shader resources to the shader stage. + + + If an overlapping resource view is already bound to an output slot, such as a rendertarget, then this API will fill the destination shader resource slot with NULL.For information about creating shader-resource views, see . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to set to the device. + void PSSetShaderResources([In] UINT StartSlot,[In] UINT NumViews,[In, Buffer] const ID3D11ShaderResourceView** ppShaderResourceViews) + + + + Set an array of sampler states to the shader pipeline stage. + + + Any sampler may be set to NULL; this invokes the default state, which is defined to be the following.StateDefault ValueFilterD3D11_FILTER_MIN_MAG_MIP_LINEARAddressUD3D11_TEXTURE_ADDRESS_CLAMPAddressVD3D11_TEXTURE_ADDRESS_CLAMPAddressWD3D11_TEXTURE_ADDRESS_CLAMPMipLODBias0MaxAnisotropy1ComparisonFuncD3D11_COMPARISON_NEVERBorderColor[0]1.0fBorderColor[1]1.0fBorderColor[2]1.0fBorderColor[3]1.0fMinLOD-FLT_MAXMaxLODFLT_MAX The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting samplers to (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Pointer to an array of sampler-state interfaces (see ). See Remarks. + void PSSetSamplers([In] UINT StartSlot,[In] UINT NumSamplers,[In, Buffer] const ID3D11SamplerState** ppSamplers) + + + + Set the constant buffers used by the shader pipeline stage. + + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to set (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffers (see ) being given to the device. + void PSSetConstantBuffers([In] UINT StartSlot,[In] UINT NumBuffers,[In, Buffer] const ID3D11Buffer** ppConstantBuffers) + + + Inner interface ComputeShaderStage. + ID3D11DeviceContext + + + + Gets an array of views for an unordered resource. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index of the first element in the zero-based array to return (ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - 1). + Number of views to get (ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - StartSlot). + void CSGetUnorderedAccessViews([In] int StartSlot,[In] int NumUAVs,[Out, Buffer] ID3D11UnorderedAccessView** ppUnorderedAccessViews) + + + + Sets an array of views for an unordered resource. + + + + Index of the first element in the zero-based array to begin setting. + A reference to an references to be set by the method. + void CSSetUnorderedAccessViews([In] int StartSlot,[In] int NumUAVs,[In, Buffer] const ID3D11UnorderedAccessView** ppUnorderedAccessViews,[In, Buffer] const int* pUAVInitialCounts) + + + + Sets an array of views for an unordered resource. + + + + Index of the first element in the zero-based array to begin setting. + A reference to an references to be set by the method. + An Append/Consume buffer offsets. A value of -1 indicates the current offset should be kept. Any other values set the hidden counter for that Appendable/Consumeable UAV. uAVInitialCount is only relevant for UAVs which have the flag, otherwise the argument is ignored. + void CSSetUnorderedAccessViews([In] int StartSlot,[In] int NumUAVs,[In, Buffer] const ID3D11UnorderedAccessView** ppUnorderedAccessViews,[In, Buffer] const int* pUAVInitialCounts) + + + + Sets an array of views for an unordered resource. + + + + Index of the first element in the zero-based array to begin setting. + A reference to an array of references to be set by the method. + void CSSetUnorderedAccessViews([In] int StartSlot,[In] int NumUAVs,[In, Buffer] const ID3D11UnorderedAccessView** ppUnorderedAccessViews,[In, Buffer] const int* pUAVInitialCounts) + + + + Sets an array of views for an unordered resource. + + + + Index of the first element in the zero-based array to begin setting. + A reference to an array of references to be set by the method. + An array of Append/Consume buffer offsets. A value of -1 indicates the current offset should be kept. Any other values set the hidden counter for that Appendable/Consumeable UAV. pUAVInitialCounts is only relevant for UAVs which have the flag, otherwise the argument is ignored. + void CSSetUnorderedAccessViews([In] int StartSlot,[In] int NumUAVs,[In, Buffer] const ID3D11UnorderedAccessView** ppUnorderedAccessViews,[In, Buffer] const int* pUAVInitialCounts) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Bind an array of shader resources to the compute-shader stage. + + + If an overlapping resource view is already bound to an output slot, such as a render target, then the method will fill the destination shader resource slot with NULL. For information about creating shader-resource views, see . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + + Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources(ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to set to the device. + void CSSetShaderResources([In] int StartSlot,[In] int NumViews,[In, Buffer] const ID3D11ShaderResourceView** ppShaderResourceViews) + + + + Sets an array of views for an unordered resource. + + + + Index of the first element in the zero-based array to begin setting. + Number of views to set. + A reference to an array of references to be set by the method. + An array of Append/Consume buffer offsets. A value of -1 indicates the current offset should be kept. Any other values set the hidden counter for that Appendable/Consumeable UAV. pUAVInitialCounts is only relevant for UAVs which have the flag, otherwise the argument is ignored. + void CSSetUnorderedAccessViews([In] int StartSlot,[In] int NumUAVs,[In, Buffer] const ID3D11UnorderedAccessView** ppUnorderedAccessViews,[In, Buffer] const int* pUAVInitialCounts) + + + + Set a compute shader to the device. + + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. The maximum number of instances a shader can have is 256. + + Pointer to a compute shader (see ). Passing in NULL disables the shader for this pipeline stage. + A reference to an array of class-instance interfaces (see ). Each interface used by a shader must have a corresponding class instance or the shader will get disabled. Set ppClassInstances to NULL if the shader does not use any interfaces. + The number of class-instance interfaces in the array. + void CSSetShader([In, Optional] ID3D11ComputeShader* pComputeShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[None] int NumClassInstances) + + + + Set an array of sampler states to the compute-shader stage. + + + Any sampler may be set to NULL; this invokes the default state, which is defined to be the following. + //Default sampler state: + D3D11_SAMPLER_DESC SamplerDesc; + SamplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; + SamplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.MipLODBias = 0; + SamplerDesc.MaxAnisotropy = 1; + SamplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER; + SamplerDesc.BorderColor[0] = 1.0f; + SamplerDesc.BorderColor[1] = 1.0f; + SamplerDesc.BorderColor[2] = 1.0f; + SamplerDesc.BorderColor[3] = 1.0f; + SamplerDesc.MinLOD = -FLT_MAX; + SamplerDesc.MaxLOD = FLT_MAX; + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting samplers to (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Pointer to an array of sampler-state interfaces (see ). See Remarks. + void CSSetSamplers([In] int StartSlot,[In] int NumSamplers,[In, Buffer] const ID3D11SamplerState** ppSamplers) + + + + Set the constant buffers used by the compute-shader stage. + + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the zero-based array to begin setting constant buffers to (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to set (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffers (see ) being given to the device. + void CSSetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[In, Buffer] const ID3D11Buffer** ppConstantBuffers) + + + + Get the compute-shader resources. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + The number of resources to get from the device. Up to a maximum of 128 slots are available for shader resources (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to be returned by the device. + void CSGetShaderResources([In] int StartSlot,[In] int NumViews,[Out, Buffer] ID3D11ShaderResourceView** ppShaderResourceViews) + + + + Gets an array of views for an unordered resource. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index of the first element in the zero-based array to return (ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - 1). + Number of views to get (ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - StartSlot). + A reference to an array of interface references (see ) to get. + void CSGetUnorderedAccessViews([In] int StartSlot,[In] int NumUAVs,[Out, Buffer] ID3D11UnorderedAccessView** ppUnorderedAccessViews) + + + + Get the compute shader currently set on the device. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Address of a reference to a Compute shader (see ) to be returned by the method. + Pointer to an array of class instance interfaces (see ). + The number of class-instance elements in the array. + void CSGetShader([Out] ID3D11ComputeShader** ppComputeShader,[Out, Buffer, Optional] ID3D11ClassInstance** ppClassInstances,[InOut] int* pNumClassInstances) + + + + Get an array of sampler state interfaces from the compute-shader stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into a zero-based array to begin getting samplers from (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers to get from a device context. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Pointer to an array of sampler-state interfaces (see ). + void CSGetSamplers([In] int StartSlot,[In] int NumSamplers,[Out, Buffer] ID3D11SamplerState** ppSamplers) + + + + Get the constant buffers used by the compute-shader stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to retrieve (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffer interface references (see ) to be returned by the method. + void CSGetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[Out, Buffer] ID3D11Buffer** ppConstantBuffers) + + + Inner interface InputAssemblerStage. + ID3D11DeviceContext + + + + Binds a single vertex buffer to the input assembler. + + Index of the slot to which to bind the vertex buffer. + A binding for the input vertex buffer. + + + + Binds an array of vertex buffers to the input assembler. + + Index of the first input slot to use for binding. The first vertex buffer is explicitly bound to the start slot; this causes each additional vertex buffer in the array to be implicitly bound to each subsequent input slot. There are 16 input slots. + An array of bindings for input vertex buffers. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Bind an input-layout object to the input-assembler stage. + + + Input-layout objects describe how vertex buffer data is streamed into the IA pipeline stage. To create an input-layout object, call . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + A reference to the input-layout object (see ), which describes the input buffers that will be read by the IA stage. + void IASetInputLayout([In, Optional] ID3D11InputLayout* pInputLayout) + + + + Bind an array of vertex buffers to the input-assembler stage. + + + For information about creating vertex buffers, see Create a Vertex Buffer. Calling this method using a buffer that is currently bound for writing (i.e. bound to the stream output pipeline stage) will effectively bind NULL instead because a buffer cannot be bound as both an input and an output at the same time. The debug layer will generate a warning whenever a resource is prevented from being bound simultaneously as an input and an output, but this will not prevent invalid data from being used by the runtime. The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + The first input slot for binding. The first vertex buffer is explicitly bound to the start slot; this causes each additional vertex buffer in the array to be implicitly bound to each subsequent input slot. There are 16 input slots (ranges from 0 to D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT - 1). + The number of vertex buffers in the array. The number of buffers (plus the starting slot) cannot exceed the total number of IA-stage input slots (ranges from 0 to D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + A reference to an array of vertex buffers (see ). The vertex buffers must have been created with the flag. + Pointer to an array of stride values; one stride value for each buffer in the vertex-buffer array. Each stride is the size (in bytes) of the elements that are to be used from that vertex buffer. + Pointer to an array of offset values; one offset value for each buffer in the vertex-buffer array. Each offset is the number of bytes between the first element of a vertex buffer and the first element that will be used. + void IASetVertexBuffers([In] int StartSlot,[In] int NumBuffers,[In, Buffer] const ID3D11Buffer** ppVertexBuffers,[In, Buffer] const int* pStrides,[In, Buffer] const int* pOffsets) + + + + Bind an index buffer to the input-assembler stage. + + + For information about creating index buffers, see {{How to: Create an Index Buffer}}. Calling this method using a buffer that is currently bound for writing (i.e. bound to the stream output pipeline stage) will effectively bind NULL instead because a buffer cannot be bound as both an input and an output at the same time. The debug layer will generate a warning whenever a resource is prevented from being bound simultaneously as an input and an output, but this will not prevent invalid data from being used by the runtime. The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + A reference to an object, that contains indices. The index buffer must have been created with the flag. + A that specifies the format of the data in the index buffer. The only formats allowed for index buffer data are 16-bit (DXGI_FORMAT_R16_UINT) and 32-bit (DXGI_FORMAT_R32_UINT) integers. + Offset (in bytes) from the start of the index buffer to the first index to use. + void IASetIndexBuffer([In, Optional] ID3D11Buffer* pIndexBuffer,[In] DXGI_FORMAT Format,[In] int Offset) + + + + Bind information about the primitive type, and data order that describes input data for the input assembler stage. + + The type of primitive and ordering of the primitive data (see ). + void IASetPrimitiveTopology([In] D3D11_PRIMITIVE_TOPOLOGY Topology) + + + + Get a reference to the input-layout object that is bound to the input-assembler stage. + + + For information about creating an input-layout object, see Creating the Input-Layout Object. Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + A reference to the input-layout object (see ), which describes the input buffers that will be read by the IA stage. + void IAGetInputLayout([Out] ID3D11InputLayout** ppInputLayout) + + + + Get the vertex buffers bound to the input-assembler stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + The input slot of the first vertex buffer to get. The first vertex buffer is explicitly bound to the start slot; this causes each additional vertex buffer in the array to be implicitly bound to each subsequent input slot. There are 16 input slots. + The number of vertex buffers to get starting at the offset. The number of buffers (plus the starting slot) cannot exceed the total number of IA-stage input slots. + A reference to an array of vertex buffers returned by the method (see ). + Pointer to an array of stride values returned by the method; one stride value for each buffer in the vertex-buffer array. Each stride value is the size (in bytes) of the elements that are to be used from that vertex buffer. + Pointer to an array of offset values returned by the method; one offset value for each buffer in the vertex-buffer array. Each offset is the number of bytes between the first element of a vertex buffer and the first element that will be used. + void IAGetVertexBuffers([In] int StartSlot,[In] int NumBuffers,[Out, Buffer, Optional] ID3D11Buffer** ppVertexBuffers,[Out, Buffer, Optional] int* pStrides,[Out, Buffer, Optional] int* pOffsets) + + + + Get a reference to the index buffer that is bound to the input-assembler stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + A reference to an index buffer returned by the method (see ). + Specifies format of the data in the index buffer (see ). These formats provide the size and type of the data in the buffer. The only formats allowed for index buffer data are 16-bit (DXGI_FORMAT_R16_UINT) and 32-bit (DXGI_FORMAT_R32_UINT) integers. + Offset (in bytes) from the start of the index buffer, to the first index to use. + void IAGetIndexBuffer([Out, Optional] ID3D11Buffer** pIndexBuffer,[Out, Optional] DXGI_FORMAT* Format,[Out, Optional] int* Offset) + + + + Get information about the primitive type, and data order that describes input data for the input assembler stage. + + A reference to the type of primitive, and ordering of the primitive data (see ). + void IAGetPrimitiveTopology([Out] D3D11_PRIMITIVE_TOPOLOGY* pTopology) + + + Inner interface OutputMergerStage. + ID3D11DeviceContext + + + + Get references to the render targets that are available to the {{output-merger stage}}. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + a depth-stencil view (see ) to be filled with the depth-stencil information from the device. + void OMGetRenderTargets([In] int NumViews,[Out, Buffer, Optional] ID3D10RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D10DepthStencilView** ppDepthStencilView) + + + + Get references to the render targets that are available to the {{output-merger stage}}. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Number of render targets to retrieve. + an array of render targets views (see ) to be filled with the render targets from the device. + void OMGetRenderTargets([In] int NumViews,[Out, Buffer, Optional] ID3D10RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D10DepthStencilView** ppDepthStencilView) + + + + Get references to the render targets and the depth-stencil buffer that are available to the {{output-merger stage}}. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Number of render targets to retrieve. + Pointer to a depth-stencil view (see ) to be filled with the depth-stencil information from the device. + an array of render targets views (see ) to be filled with the render targets from the device. + void OMGetRenderTargets([In] int NumViews,[Out, Buffer, Optional] ID3D10RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D10DepthStencilView** ppDepthStencilView) + + + + Get the {{blend state}} of the output-merger stage. + + + The reference count of the returned interface will be incremented by one when the blend state is retrieved. Applications must release returned reference(s) when they are no longer needed, or else there will be a memory leak. + + Array of blend factors, one for each RGBA component. + Pointer to a {{sample mask}}. + a reference to a blend-state interface (see ). + void OMGetBlendState([Out, Optional] ID3D10BlendState** ppBlendState,[Out, Optional] float BlendFactor[4],[Out, Optional] int* pSampleMask) + + + + Gets the {{depth-stencil}} state of the output-merger stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + Pointer to the stencil reference value used in the {{depth-stencil}} test. + a reference to a depth-stencil state interface (see ) to be filled with information from the device. + void OMGetDepthStencilState([Out, Optional] ID3D10DepthStencilState** ppDepthStencilState,[Out, Optional] int* pStencilRef) + + + + Gets an array of views for an unordered resource. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index of the first element in the zero-based array to return (ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - 1). + Number of views to get (ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - StartSlot). + void OMGetRenderTargetsAndUnorderedAccessViews([In] int NumRTVs,[Out, Buffer, Optional] ID3D11RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D11DepthStencilView** ppDepthStencilView,[In] int UAVStartSlot,[In] int NumUAVs,[Out, Buffer, Optional] ID3D11UnorderedAccessView** ppUnorderedAccessViews) + + + + Binds a set of render targets to the output-merger stage. + + A set of render target views to bind. + + + + Binds a single render target to the output-merger stage. + + A view of the render target to bind. + + + + Binds a depth-stencil buffer and a set of render targets to the output-merger stage. + + A view of the depth-stencil buffer to bind. + A set of render target views to bind. + + + + Binds a depth-stencil buffer and a single render target to the output-merger stage. + + A view of the depth-stencil buffer to bind. + A view of the render target to bind. + + + + Binds a set of unordered access views and a single render target to the output-merger stage. + + Index into a zero-based array to begin setting unordered access views. + A set of unordered access views to bind. + A view of the render target to bind. + + + + Binds a set of unordered access views and a set of render targets to the output-merger stage. + + Index into a zero-based array to begin setting unordered access views. + A set of unordered access views to bind. + A set of render target views to bind. + + + + Binds a depth-stencil buffer, a set of unordered access views, and a single render target to the output-merger stage. + + A view of the depth-stencil buffer to bind. + Index into a zero-based array to begin setting unordered access views. + A set of unordered access views to bind. + A view of the render target to bind. + + + + Binds a depth-stencil buffer, a set of unordered access views, and a set of render targets to the output-merger stage. + + A view of the depth-stencil buffer to bind. + Index into a zero-based array to begin setting unordered access views. + A set of unordered access views to bind. + A set of render target views to bind. + + + + Binds a set of unordered access views and a single render target to the output-merger stage. + + Index into a zero-based array to begin setting unordered access views. + A set of unordered access views to bind. + A view of the render target to bind. + An array of Append/Consume buffer offsets. A value of -1 indicates the current offset should be kept. Any other values set the hidden counter for that Appendable/Consumeable UAV. + + + + Binds a set of unordered access views and a set of render targets to the output-merger stage. + + Index into a zero-based array to begin setting unordered access views. + A set of unordered access views to bind. + A set of render target views to bind. + An array of Append/Consume buffer offsets. A value of -1 indicates the current offset should be kept. Any other values set the hidden counter for that Appendable/Consumeable UAV. + + + + Binds a depth-stencil buffer, a set of unordered access views, and a single render target to the output-merger stage. + + A view of the depth-stencil buffer to bind. + Index into a zero-based array to begin setting unordered access views. + A set of unordered access views to bind. + A view of the render target to bind. + An array of Append/Consume buffer offsets. A value of -1 indicates the current offset should be kept. Any other values set the hidden counter for that Appendable/Consumeable UAV. + + + + Binds a depth-stencil buffer, a set of unordered access views, and a set of render targets to the output-merger stage. + + A view of the depth-stencil buffer to bind. + Index into a zero-based array to begin setting unordered access views. + A set of unordered access views to bind. + A set of render target views to bind. + An array of Append/Consume buffer offsets. A value of -1 indicates the current offset should be kept. Any other values set the hidden counter for that Appendable/Consumeable UAV. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Bind one or more render targets atomically and the depth-stencil buffer to the output-merger stage. + + + The maximum number of active render targets a device can have active at any given time is set by a #define in D3D11.h called D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT. It is invalid to try to set the same subresource to multiple render target slots. Any render targets not defined by this call are set to NULL. If any subresources are also currently bound for reading in a different stage or writing (perhaps in a different part of the pipeline), those bind points will be NULL'ed out to prevent the same subresource from being read and written simultaneously in a single rendering operation. The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. If the render-target views were created from an array resource type, then all of the render-target views must have the same array size. This restriction also applies to the depth-stencil view, its array size must match that of the render-target views being bound. + + Number of render targets to bind (ranges between 0 and D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT). + Pointer to an array of render targets (see ) to bind to the device. If this parameter is NULL, no render targets are bound. See Remarks. + Pointer to a depth-stencil view (see ) to bind to the device. If this parameter is NULL, the depth-stencil state is not bound. + void OMSetRenderTargets([In] int NumViews,[In, Buffer, Optional] const ID3D11RenderTargetView** ppRenderTargetViews,[In, Optional] ID3D11DepthStencilView* pDepthStencilView) + + + + Binds resources to the output-merger stage. + + + For pixel shaders, the render targets and unordered-access views share the same resource slots when being written out. This means that UAVs must be given an offset so that they are placed in the slots after the render target views that are being bound. Note??RTVs, DSV, and UAVs cannot be set independently; they all need to be set at the same time. Two RTVs conflict if they share a subresource (and therefore share the same resource). Two UAVs conflict if they share a subresource (and therefore share the same resource). An RTV conflicts with a UAV if they share a subresource or share a bind point. OMSetRenderTargetsAndUnorderedAccessViews operates properly in the following situations: NumViews != D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL and NumUAVs != D3D11_KEEP_UNORDERED_ACCESS_VIEWS The following conditions must be true for OMSetRenderTargetsAndUnorderedAccessViews to succeed and for the runtime to pass the bind information to the driver: NumViews <= 8 UAVStartSlot >= NumViews UAVStartSlot + NumUAVs <= 8 There must be no conflicts in the set of all ppRenderTargetViews and ppUnorderedAccessView. ppDepthStencilView must match the render-target views. For more information about resource views, see {{Introduction to a Resource in Direct3D 11}}. OMSetRenderTargetsAndUnorderedAccessViews performs the following tasks: Unbinds all currently bound conflicting resources (stream-output target resources (SOTargets), compute shader (CS) UAVs, shader-resource views (SRVs)). Binds ppRenderTargetViews, ppDepthStencilView, and ppUnorderedAccessView. NumViews == D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL In this situation, OMSetRenderTargetsAndUnorderedAccessViews binds only UAVs. The following conditions must be true for OMSetRenderTargetsAndUnorderedAccessViews to succeed and for the runtime to pass the bind information to the driver: UAVStartSlot + NumUAVs <= 8 There must be no conflicts in ppUnorderedAccessView. OMSetRenderTargetsAndUnorderedAccessViews unbinds the following items: All RTVs in slots >= UAVStartSlot All RTVs that conflict with any UAVs in ppUnorderedAccessView All currently bound resources (SOTargets, CS UAVs, SRVs) that conflict with ppUnorderedAccessView OMSetRenderTargetsAndUnorderedAccessViews binds ppUnorderedAccessView. OMSetRenderTargetsAndUnorderedAccessViews ignores ppDepthStencilView, and the current depth-stencil view remains bound. NumUAVs == D3D11_KEEP_UNORDERED_ACCESS_VIEWS In this situation, OMSetRenderTargetsAndUnorderedAccessViews binds only RTVs and DSV. The following conditions must be true for OMSetRenderTargetsAndUnorderedAccessViews to succeed and for the runtime to pass the bind information to the driver: NumViews <= 8 There must be no conflicts in ppRenderTargetViews. ppDepthStencilView must match the render-target views. For more information about resource views, see {{Introduction to a Resource in Direct3D 11}}. OMSetRenderTargetsAndUnorderedAccessViews unbinds the following items: All UAVs in slots < NumViews All UAVs that conflict with any RTVs in ppRenderTargetViews All currently bound resources (SOTargets, CS UAVs, SRVs) that conflict with ppRenderTargetViews OMSetRenderTargetsAndUnorderedAccessViews binds ppRenderTargetViews and ppDepthStencilView. OMSetRenderTargetsAndUnorderedAccessViews ignores UAVStartSlot. + + Number of render-target views (ppRenderTargetViews) and depth-stencil view (ppDepthStencilView) to bind. If you set NumViews to D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL (0xffffffff), this method does not modify the currently bound render-target views (RTVs) and also does not modify depth-stencil view (DSV). + Pointer to an array of s, which represent render-target views. Specify NULL to set none. + Pointer to a , which represents a depth-stencil view. Specify NULL to set none. + Index into a zero-based array to begin setting unordered-access views (ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - 1). For pixel shaders UAVStartSlot should be equal to the number of render-target views being bound. + Number of unordered-access views (UAVs) in ppUnorderedAccessView. If you set NumUAVs to D3D11_KEEP_UNORDERED_ACCESS_VIEWS (0xffffffff), this method does not modify the currently bound unordered-access views. + Pointer to an array of s, which represent unordered-access views. + An array of Append/Consume buffer offsets. A value of -1 indicates the current offset should be kept. Any other values set the hidden counter for that Appendable/Consumeable UAV. pUAVInitialCounts is only relevant for UAVs that have the flag, otherwise the argument is ignored. + void OMSetRenderTargetsAndUnorderedAccessViews([In] int NumRTVs,[In, Buffer, Optional] const ID3D11RenderTargetView** ppRenderTargetViews,[In, Optional] ID3D11DepthStencilView* pDepthStencilView,[In] int UAVStartSlot,[In] int NumUAVs,[In, Buffer, Optional] const ID3D11UnorderedAccessView** ppUnorderedAccessViews,[In, Buffer, Optional] const int* pUAVInitialCounts) + + + + Set the blend state of the output-merger stage. + + + Blend state is used by the output-merger stage to determine how to blend together two pixel values. The two values are commonly the current pixel value and the pixel value already in the output render target. Use the {{blend operation}} to control where the two pixel values come from and how they are mathematically combined. To create a blend-state interface, call . Passing in NULL for the blend-state interface indicates to the runtime to set a default blending state. The following table indicates the default blending parameters. StateDefault Value AlphaToCoverageEnableFALSE BlendEnableFALSE[8] SrcBlendD3D11_BLEND_ONE DstBlendD3D11_BLEND_ZERO BlendOpD3D11_BLEND_OP_ADD SrcBlendAlphaD3D11_BLEND_ONE DstBlendAlphaD3D11_BLEND_ZERO BlendOpAlphaD3D11_BLEND_OP_ADD RenderTargetWriteMask[8]D3D11_COLOR_WRITE_ENABLE_ALL[8] ? A sample mask determines which samples get updated in all the active render targets. The mapping of bits in a sample mask to samples in a multisample render target is the responsibility of an individual application. A sample mask is always applied; it is independent of whether multisampling is enabled, and does not depend on whether an application uses multisample render targets. The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Pointer to a blend-state interface (see ). Passing in NULL implies a default blend state. See remarks for further details. + Array of blend factors, one for each RGBA component. This requires a blend state object that specifies the option. + 32-bit sample coverage. The default value is 0xffffffff. See remarks. + void OMSetBlendState([In, Optional] ID3D11BlendState* pBlendState,[In, Optional] const SHARPDX_COLOR4* BlendFactor,[In] int SampleMask) + + + + Sets the depth-stencil state of the output-merger stage. + + + To create a depth-stencil state interface, call . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Pointer to a depth-stencil state interface (see ) to bind to the device. Set this to NULL to use the default state listed in . + Reference value to perform against when doing a depth-stencil test. See remarks. + void OMSetDepthStencilState([In, Optional] ID3D11DepthStencilState* pDepthStencilState,[In] int StencilRef) + + + + Get references to the resources bound to the output-merger stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Number of render targets to retrieve. + Pointer to an array of s which represent render target views. Specify NULL for this parameter when retrieval of a render target is not needed. + Pointer to a , which represents a depth-stencil view. Specify NULL for this parameter when retrieval of the depth-stencil view is not needed. + void OMGetRenderTargets([In] int NumViews,[Out, Buffer, Optional] ID3D11RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D11DepthStencilView** ppDepthStencilView) + + + + Get references to the resources bound to the output-merger stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call {{IUnknown::Release}} on the returned interfaces when they are no longer needed to avoid memory leaks. + + The number of render-target views to retrieve. + Pointer to an array of s, which represent render-target views. Specify NULL for this parameter when retrieval of render-target views is not required. + Pointer to a , which represents a depth-stencil view. Specify NULL for this parameter when retrieval of the depth-stencil view is not required. + Index into a zero-based array to begin retrieving unordered-access views (ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - 1). For pixel shaders UAVStartSlot should be equal to the number of render-target views that are bound. + Number of unordered-access views to return in ppUnorderedAccessViews. This number ranges from 0 to D3D11_PS_CS_UAV_REGISTER_COUNT - UAVStartSlot. + Pointer to an array of s, which represent unordered-access views that are retrieved. Specify NULL for this parameter when retrieval of unordered-access views is not required. + void OMGetRenderTargetsAndUnorderedAccessViews([In] int NumRTVs,[Out, Buffer, Optional] ID3D11RenderTargetView** ppRenderTargetViews,[Out, Optional] ID3D11DepthStencilView** ppDepthStencilView,[In] int UAVStartSlot,[In] int NumUAVs,[Out, Buffer, Optional] ID3D11UnorderedAccessView** ppUnorderedAccessViews) + + + + Get the blend state of the output-merger stage. + + + The reference count of the returned interface will be incremented by one when the blend state is retrieved. Applications must release returned reference(s) when they are no longer needed, or else there will be a memory leak. + + Address of a reference to a blend-state interface (see ). + Array of blend factors, one for each RGBA component. + Pointer to a {{sample mask}}. + void OMGetBlendState([Out, Optional] ID3D11BlendState** ppBlendState,[Out, Optional] SHARPDX_COLOR4* BlendFactor,[Out, Optional] int* pSampleMask) + + + + Gets the depth-stencil state of the output-merger stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Address of a reference to a depth-stencil state interface (see ) to be filled with information from the device. + Pointer to the stencil reference value used in the depth-stencil test. + void OMGetDepthStencilState([Out, Optional] ID3D11DepthStencilState** ppDepthStencilState,[Out, Optional] int* pStencilRef) + + + + Gets or sets the blend factor. + + The blend factor. + + + + Gets or sets the blend sample mask. + + The blend sample mask. + + + + Gets or sets the state of the blend. + + The state of the blend. + + + + Gets or sets the depth stencil reference. + + The depth stencil reference. + + + + Gets or sets the state of the depth stencil. + + The state of the depth stencil. + + + Inner interface RasterizerStage. + ID3D11DeviceContext + + + + Get the array of {{viewports}} bound to the {{rasterizer stage}} + + An array of viewports (see ). + void RSGetViewports([InOut] int* NumViewports,[Out, Buffer, Optional] D3D10_VIEWPORT* pViewports) + + + + Get the array of {{viewports}} bound to the {{rasterizer stage}} + + An array of viewports (see ). + void RSGetViewports([InOut] int* NumViewports,[Out, Buffer, Optional] D3D10_VIEWPORT* pViewports) + + + + Get the array of {{scissor rectangles}} bound to the {{rasterizer stage}}. + + An array of scissor rectangles (see ). + void RSGetScissorRects([InOut] int* NumRects,[Out, Buffer, Optional] D3D10_RECT* pRects) + + + + Get the array of {{scissor rectangles}} bound to the {{rasterizer stage}}. + + An array of scissor rectangles (see ). + void RSGetScissorRects([InOut] int* NumRects,[Out, Buffer, Optional] D3D10_RECT* pRects) + + + + Binds a single scissor rectangle to the rasterizer stage. + + The scissor rectangle to bind. + + + + Binds a set of scissor rectangles to the rasterizer stage. + + The set of scissor rectangles to bind. + + + + Binds a set of viewports to the rasterizer stage. + + The set of viewports to bind. + + + + Binds a single viewport to the rasterizer stage. + + The viewport to bind. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set the {{rasterizer state}} for the rasterizer stage of the pipeline. + + + To create a rasterizer state interface, call . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Pointer to a rasterizer-state interface (see ) to bind to the pipeline. + void RSSetState([In, Optional] ID3D11RasterizerState* pRasterizerState) + + + + Bind an array of viewports to the rasterizer stage of the pipeline. + + + All viewports must be set atomically as one operation. Any viewports not defined by the call are disabled. Which viewport to use is determined by the SV_ViewportArrayIndex semantic output by a geometry shader; if a geometry shader does not specify the semantic, Direct3D will use the first viewport in the array. + + Number of viewports to bind. + An array of structures to bind to the device. See the structure page for details about how the viewport size is dependent on the device feature level which has changed between Direct3D 11 and Direct3D 10. + void RSSetViewports([In] int NumViewports,[In, Buffer, Optional] const D3D11_VIEWPORT* pViewports) + + + + Bind an array of scissor rectangles to the rasterizer stage. + + + All scissor rects must be set atomically as one operation. Any scissor rects not defined by the call are disabled. The scissor rectangles will only be used if ScissorEnable is set to true in the rasterizer state (see ). Which scissor rectangle to use is determined by the SV_ViewportArrayIndex semantic output by a geometry shader (see shader semantic syntax). If a geometry shader does not make use of the SV_ViewportArrayIndex semantic then Direct3D will use the first scissor rectangle in the array. Each scissor rectangle in the array corresponds to a viewport in an array of viewports (see ). + + Number of scissor rectangles to bind. + An array of scissor rectangles (see ). + void RSSetScissorRects([In] int NumRects,[In, Buffer, Optional] const D3D11_RECT* pRects) + + + + Get the {{rasterizer state}} from the rasterizer stage of the pipeline. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Address of a reference to a rasterizer-state interface (see ) to fill with information from the device. + void RSGetState([Out] ID3D11RasterizerState** ppRasterizerState) + + + + Get the array of viewports bound to the rasterizer stage + + The input specifies the number of viewports (ranges from 0 to D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) in pViewports, the output contains the actual number of viewports returned. If pViewports is NULL, this will be filled with the number of viewports currently bound. + An array of structures that are bound to the device. If the number of viewports (in pNumViewports) is greater than the actual number of viewports currently bound, then unused members of the array will contain 0. See the structure page for details about how the viewport size is dependent on the device feature level which has changed between Direct3D 11 and Direct3D 10. + void RSGetViewports([InOut] int* pNumViewports,[Out, Buffer, Optional] D3D11_VIEWPORT* pViewports) + + + + Get the array of scissor rectangles bound to the rasterizer stage. + + The number of scissor rectangles (ranges between 0 and D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) bound; set pRects to NULL to use pNumRects to see how many rectangles would be returned. + An array of scissor rectangles (see ). If NumRects is greater than the number of scissor rects currently bound, then unused members of the array will contain 0. + void RSGetScissorRects([InOut] int* pNumRects,[Out, Buffer, Optional] D3D11_RECT* pRects) + + + + Get the {{rasterizer state}} from the rasterizer stage of the pipeline. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + void RSGetState([Out] ID3D11RasterizerState** ppRasterizerState) + + + Inner interface VertexShaderStage. + ID3D11DeviceContext + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set the constant buffers used by the vertex shader pipeline stage. + + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to set (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffers (see ) being given to the device. + void VSSetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[In, Buffer] const ID3D11Buffer** ppConstantBuffers) + + + + Set a vertex shader to the device. + + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. The maximum number of instances a shader can have is 256. + + Pointer to a vertex shader (see ). Passing in NULL disables the shader for this pipeline stage. + A reference to an array of class-instance interfaces (see ). Each interface used by a shader must have a corresponding class instance or the shader will get disabled. Set ppClassInstances to NULL if the shader does not use any interfaces. + The number of class-instance interfaces in the array. + void VSSetShader([In, Optional] ID3D11VertexShader* pVertexShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[None] int NumClassInstances) + + + + Bind an array of shader resources to the vertex-shader stage. + + + If an overlapping resource view is already bound to an output slot, such as a rendertarget, then this API will fill the destination shader resource slot with NULL. For information about creating shader-resource views, see . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting shader resources to (range is from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources (range is from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to set to the device. + void VSSetShaderResources([In] int StartSlot,[In] int NumViews,[In, Buffer] const ID3D11ShaderResourceView** ppShaderResourceViews) + + + + Set an array of sampler states to the vertex shader pipeline stage. + + + Any sampler may be set to NULL; this invokes the default state, which is defined to be the following. + //Default sampler state: + D3D11_SAMPLER_DESC SamplerDesc; + SamplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; + SamplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.MipLODBias = 0; + SamplerDesc.MaxAnisotropy = 1; + SamplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER; + SamplerDesc.BorderColor[0] = 1.0f; + SamplerDesc.BorderColor[1] = 1.0f; + SamplerDesc.BorderColor[2] = 1.0f; + SamplerDesc.BorderColor[3] = 1.0f; + SamplerDesc.MinLOD = -FLT_MAX; + SamplerDesc.MaxLOD = FLT_MAX; + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting samplers to (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Pointer to an array of sampler-state interfaces (see ). See Remarks. + void VSSetSamplers([In] int StartSlot,[In] int NumSamplers,[In, Buffer] const ID3D11SamplerState** ppSamplers) + + + + Get the constant buffers used by the vertex shader pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to retrieve (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffer interface references (see ) to be returned by the method. + void VSGetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[Out, Buffer] ID3D11Buffer** ppConstantBuffers) + + + + Get the vertex shader currently set on the device. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Address of a reference to a vertex shader (see ) to be returned by the method. + Pointer to an array of class instance interfaces (see ). + The number of class-instance elements in the array. + void VSGetShader([Out] ID3D11VertexShader** ppVertexShader,[Out, Buffer, Optional] ID3D11ClassInstance** ppClassInstances,[InOut] int* pNumClassInstances) + + + + Get the vertex shader resources. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + The number of resources to get from the device. Up to a maximum of 128 slots are available for shader resources (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to be returned by the device. + void VSGetShaderResources([In] int StartSlot,[In] int NumViews,[Out, Buffer] ID3D11ShaderResourceView** ppShaderResourceViews) + + + + Get an array of sampler states from the vertex shader pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into a zero-based array to begin getting samplers from (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers to get from a device context. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Arry of sampler-state interface references (see ) to be returned by the device. + void VSGetSamplers([In] int StartSlot,[In] int NumSamplers,[Out, Buffer] ID3D11SamplerState** ppSamplers) + + + Inner interface PixelShaderStage. + ID3D11DeviceContext + + + + Initializes a new instance of the class. + + The native pointer. + + + + Bind an array of shader resources to the pixel shader stage. + + + If an overlapping resource view is already bound to an output slot, such as a rendertarget, then this API will fill the destination shader resource slot with NULL. For information about creating shader-resource views, see . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to set to the device. + void PSSetShaderResources([In] int StartSlot,[In] int NumViews,[In, Buffer] const ID3D11ShaderResourceView** ppShaderResourceViews) + + + + Sets a pixel shader to the device. + + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. The maximum number of instances a shader can have is 256. Set ppClassInstances to NULL if no interfaces are used in the shader. If it is non-NULL, the number of class instances must match the number of interfaces used in the shader. Furthermore, each interface reference must have a corresponding class instance or the assigned shader will be disabled. + + Pointer to a pixel shader (see ). Passing in NULL disables the shader for this pipeline stage. + A reference to an array of class-instance interfaces (see ). Each interface used by a shader must have a corresponding class instance or the shader will get disabled. Set ppClassInstances to NULL if the shader does not use any interfaces. + The number of class-instance interfaces in the array. + void PSSetShader([In, Optional] ID3D11PixelShader* pPixelShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[None] int NumClassInstances) + + + + Set an array of sampler states to the pixel shader pipeline stage. + + + Any sampler may be set to NULL; this invokes the default state, which is defined to be the following. StateDefault Value FilterD3D11_FILTER_MIN_MAG_MIP_LINEAR AddressUD3D11_TEXTURE_ADDRESS_CLAMP AddressVD3D11_TEXTURE_ADDRESS_CLAMP AddressWD3D11_TEXTURE_ADDRESS_CLAMP MipLODBias0 MaxAnisotropy1 ComparisonFuncD3D11_COMPARISON_NEVER BorderColor[0]1.0f BorderColor[1]1.0f BorderColor[2]1.0f BorderColor[3]1.0f MinLOD-FLT_MAX MaxLODFLT_MAX ? The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting samplers to (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Pointer to an array of sampler-state interfaces (see ). See Remarks. + void PSSetSamplers([In] int StartSlot,[In] int NumSamplers,[In, Buffer] const ID3D11SamplerState** ppSamplers) + + + + Set the constant buffers used by the pixel shader pipeline stage. + + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to set (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffers (see ) being given to the device. + void PSSetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[In, Buffer] const ID3D11Buffer** ppConstantBuffers) + + + + Get the pixel shader resources. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + The number of resources to get from the device. Up to a maximum of 128 slots are available for shader resources (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to be returned by the device. + void PSGetShaderResources([In] int StartSlot,[In] int NumViews,[Out, Buffer] ID3D11ShaderResourceView** ppShaderResourceViews) + + + + Get the pixel shader currently set on the device. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Address of a reference to a pixel shader (see ) to be returned by the method. + Pointer to an array of class instance interfaces (see ). + The number of class-instance elements in the array. + void PSGetShader([Out] ID3D11PixelShader** ppPixelShader,[Out, Buffer, Optional] ID3D11ClassInstance** ppClassInstances,[InOut] int* pNumClassInstances) + + + + Get an array of sampler states from the pixel shader pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into a zero-based array to begin getting samplers from (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers to get from a device context. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Arry of sampler-state interface references (see ) to be returned by the device. + void PSGetSamplers([In] int StartSlot,[In] int NumSamplers,[Out, Buffer] ID3D11SamplerState** ppSamplers) + + + + Get the constant buffers used by the pixel shader pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to retrieve (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffer interface references (see ) to be returned by the method. + void PSGetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[Out, Buffer] ID3D11Buffer** ppConstantBuffers) + + + Inner interface GeometryShaderStage. + ID3D11DeviceContext + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set the constant buffers used by the geometry shader pipeline stage. + + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to set (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffers (see ) being given to the device. + void GSSetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[In, Buffer] const ID3D11Buffer** ppConstantBuffers) + + + + Set a geometry shader to the device. + + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. The maximum number of instances a shader can have is 256. + + Pointer to a geometry shader (see ). Passing in NULL disables the shader for this pipeline stage. + A reference to an array of class-instance interfaces (see ). Each interface used by a shader must have a corresponding class instance or the shader will get disabled. Set ppClassInstances to NULL if the shader does not use any interfaces. + The number of class-instance interfaces in the array. + void GSSetShader([In, Optional] ID3D11GeometryShader* pShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[None] int NumClassInstances) + + + + Bind an array of shader resources to the geometry shader stage. + + + If an overlapping resource view is already bound to an output slot, such as a render target, then the method will fill the destination shader resource slot with NULL. For information about creating shader-resource views, see . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources(ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to set to the device. + void GSSetShaderResources([In] int StartSlot,[In] int NumViews,[In, Buffer] const ID3D11ShaderResourceView** ppShaderResourceViews) + + + + Set an array of sampler states to the geometry shader pipeline stage. + + + Any sampler may be set to NULL; this invokes the default state, which is defined to be the following. + //Default sampler state: + D3D11_SAMPLER_DESC SamplerDesc; + SamplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; + SamplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.MipLODBias = 0; + SamplerDesc.MaxAnisotropy = 1; + SamplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER; + SamplerDesc.BorderColor[0] = 1.0f; + SamplerDesc.BorderColor[1] = 1.0f; + SamplerDesc.BorderColor[2] = 1.0f; + SamplerDesc.BorderColor[3] = 1.0f; + SamplerDesc.MinLOD = -FLT_MAX; + SamplerDesc.MaxLOD = FLT_MAX; + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting samplers to (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Pointer to an array of sampler-state interfaces (see ). See Remarks. + void GSSetSamplers([In] int StartSlot,[In] int NumSamplers,[In, Buffer] const ID3D11SamplerState** ppSamplers) + + + + Get the constant buffers used by the geometry shader pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to retrieve (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffer interface references (see ) to be returned by the method. + void GSGetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[Out, Buffer] ID3D11Buffer** ppConstantBuffers) + + + + Get the geometry shader currently set on the device. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Address of a reference to a geometry shader (see ) to be returned by the method. + Pointer to an array of class instance interfaces (see ). + The number of class-instance elements in the array. + void GSGetShader([Out] ID3D11GeometryShader** ppGeometryShader,[Out, Buffer, Optional] ID3D11ClassInstance** ppClassInstances,[InOut] int* pNumClassInstances) + + + + Get the geometry shader resources. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + The number of resources to get from the device. Up to a maximum of 128 slots are available for shader resources (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to be returned by the device. + void GSGetShaderResources([In] int StartSlot,[In] int NumViews,[Out, Buffer] ID3D11ShaderResourceView** ppShaderResourceViews) + + + + Get an array of sampler state interfaces from the geometry shader pipeline stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into a zero-based array to begin getting samplers from (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers to get from a device context. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Pointer to an array of sampler-state interfaces (see ). + void GSGetSamplers([In] int StartSlot,[In] int NumSamplers,[Out, Buffer] ID3D11SamplerState** ppSamplers) + + + Inner interface DomainShaderStage. + ID3D11DeviceContext + + + + Initializes a new instance of the class. + + The native pointer. + + + + Bind an array of shader resources to the domain-shader stage. + + + If an overlapping resource view is already bound to an output slot, such as a render target, then the method will fill the destination shader resource slot with NULL. For information about creating shader-resource views, see . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources(ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to set to the device. + void DSSetShaderResources([In] int StartSlot,[In] int NumViews,[In, Buffer] const ID3D11ShaderResourceView** ppShaderResourceViews) + + + + Set a domain shader to the device. + + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. The maximum number of instances a shader can have is 256. + + Pointer to a domain shader (see ). Passing in NULL disables the shader for this pipeline stage. + A reference to an array of class-instance interfaces (see ). Each interface used by a shader must have a corresponding class instance or the shader will get disabled. Set ppClassInstances to NULL if the shader does not use any interfaces. + The number of class-instance interfaces in the array. + void DSSetShader([In, Optional] ID3D11DomainShader* pDomainShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[None] int NumClassInstances) + + + + Set an array of sampler states to the domain-shader stage. + + + Any sampler may be set to NULL; this invokes the default state, which is defined to be the following. + //Default sampler state: + D3D11_SAMPLER_DESC SamplerDesc; + SamplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; + SamplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.MipLODBias = 0; + SamplerDesc.MaxAnisotropy = 1; + SamplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER; + SamplerDesc.BorderColor[0] = 1.0f; + SamplerDesc.BorderColor[1] = 1.0f; + SamplerDesc.BorderColor[2] = 1.0f; + SamplerDesc.BorderColor[3] = 1.0f; + SamplerDesc.MinLOD = -FLT_MAX; + SamplerDesc.MaxLOD = FLT_MAX; + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting samplers to (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Pointer to an array of sampler-state interfaces (see ). See Remarks. + void DSSetSamplers([In] int StartSlot,[In] int NumSamplers,[In, Buffer] const ID3D11SamplerState** ppSamplers) + + + + Set the constant buffers used by the domain-shader stage. + + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the zero-based array to begin setting constant buffers to (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to set (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffers (see ) being given to the device. + void DSSetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[In, Buffer] const ID3D11Buffer** ppConstantBuffers) + + + + Get the domain-shader resources. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + The number of resources to get from the device. Up to a maximum of 128 slots are available for shader resources (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to be returned by the device. + void DSGetShaderResources([In] int StartSlot,[In] int NumViews,[Out, Buffer] ID3D11ShaderResourceView** ppShaderResourceViews) + + + + Get the domain shader currently set on the device. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Address of a reference to a domain shader (see ) to be returned by the method. + Pointer to an array of class instance interfaces (see ). + The number of class-instance elements in the array. + void DSGetShader([Out] ID3D11DomainShader** ppDomainShader,[Out, Buffer, Optional] ID3D11ClassInstance** ppClassInstances,[InOut] int* pNumClassInstances) + + + + Get an array of sampler state interfaces from the domain-shader stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into a zero-based array to begin getting samplers from (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers to get from a device context. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Pointer to an array of sampler-state interfaces (see ). + void DSGetSamplers([In] int StartSlot,[In] int NumSamplers,[Out, Buffer] ID3D11SamplerState** ppSamplers) + + + + Get the constant buffers used by the domain-shader stage. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to retrieve (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffer interface references (see ) to be returned by the method. + void DSGetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[Out, Buffer] ID3D11Buffer** ppConstantBuffers) + + + Inner interface HullShaderStage. + ID3D11DeviceContext + + + + Initializes a new instance of the class. + + The native pointer. + + + + Bind an array of shader resources to the {{hull-shader stage}}. + + + If an overlapping resource view is already bound to an output slot, such as a render target, then the method will fill the destination shader resource slot with NULL. For information about creating shader-resource views, see . The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting shader resources to (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + Number of shader resources to set. Up to a maximum of 128 slots are available for shader resources(ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to set to the device. + void HSSetShaderResources([In] int StartSlot,[In] int NumViews,[In, Buffer] const ID3D11ShaderResourceView** ppShaderResourceViews) + + + + Set a hull shader to the device. + + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. The maximum number of instances a shader can have is 256. + + Pointer to a hull shader (see ). Passing in NULL disables the shader for this pipeline stage. + A reference to an array of class-instance interfaces (see ). Each interface used by a shader must have a corresponding class instance or the shader will get disabled. Set ppClassInstances to NULL if the shader does not use any interfaces. + The number of class-instance interfaces in the array. + void HSSetShader([In, Optional] ID3D11HullShader* pHullShader,[In, Buffer, Optional] const ID3D11ClassInstance** ppClassInstances,[None] int NumClassInstances) + + + + Set an array of sampler states to the {{hull-shader stage}}. + + + Any sampler may be set to NULL; this invokes the default state, which is defined to be the following. + //Default sampler state: + D3D11_SAMPLER_DESC SamplerDesc; + SamplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; + SamplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP; + SamplerDesc.MipLODBias = 0; + SamplerDesc.MaxAnisotropy = 1; + SamplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER; + SamplerDesc.BorderColor[0] = 1.0f; + SamplerDesc.BorderColor[1] = 1.0f; + SamplerDesc.BorderColor[2] = 1.0f; + SamplerDesc.BorderColor[3] = 1.0f; + SamplerDesc.MinLOD = -FLT_MAX; + SamplerDesc.MaxLOD = FLT_MAX; + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the zero-based array to begin setting samplers to (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers in the array. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Pointer to an array of sampler-state interfaces (see ). See Remarks. + void HSSetSamplers([In] int StartSlot,[In] int NumSamplers,[In, Buffer] const ID3D11SamplerState** ppSamplers) + + + + Set the constant buffers used by the {{hull-shader stage}}. + + + The method will hold a reference to the interfaces passed in. This differs from the device state behavior in Direct3D 10. + + Index into the device's zero-based array to begin setting constant buffers to (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to set (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffers (see ) being given to the device. + void HSSetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[In, Buffer] const ID3D11Buffer** ppConstantBuffers) + + + + Get the hull-shader resources. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin getting shader resources from (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1). + The number of resources to get from the device. Up to a maximum of 128 slots are available for shader resources (ranges from 0 to D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot). + Array of {{shader resource view}} interfaces to be returned by the device. + void HSGetShaderResources([In] int StartSlot,[In] int NumViews,[Out, Buffer] ID3D11ShaderResourceView** ppShaderResourceViews) + + + + Get the hull shader currently set on the device. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Address of a reference to a hull shader (see ) to be returned by the method. + Pointer to an array of class instance interfaces (see ). + The number of class-instance elements in the array. + void HSGetShader([Out] ID3D11HullShader** ppHullShader,[Out, Buffer, Optional] ID3D11ClassInstance** ppClassInstances,[InOut] int* pNumClassInstances) + + + + Get an array of sampler state interfaces from the {{hull-shader stage}}. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into a zero-based array to begin getting samplers from (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1). + Number of samplers to get from a device context. Each pipeline stage has a total of 16 sampler slots available (ranges from 0 to D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot). + Pointer to an array of sampler-state interfaces (see ). + void HSGetSamplers([In] int StartSlot,[In] int NumSamplers,[Out, Buffer] ID3D11SamplerState** ppSamplers) + + + + Get the constant buffers used by the {{hull-shader stage}}. + + + Any returned interfaces will have their reference count incremented by one. Applications should call IUnknown::Release on the returned interfaces when they are no longer needed to avoid memory leaks. + + Index into the device's zero-based array to begin retrieving constant buffers from (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1). + Number of buffers to retrieve (ranges from 0 to D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot). + Array of constant buffer interface references (see ) to be returned by the method. + void HSGetConstantBuffers([In] int StartSlot,[In] int NumBuffers,[Out, Buffer] ID3D11Buffer** ppConstantBuffers) + + + + A domain-shader interface manages an executable program (a domain shader) that controls the domain-shader stage. + + ID3D11DomainShader + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + A dynamic class linkage interface. + + + + Initializes a new instance of the class. + + The native pointer. + + + + Encapsulates forward and inverse FFTs. + + ID3DX11FFT + + + + Initializes a new instance of the class. + + The device context used to create the FFT. + Information that describes the shape of the FFT data as well as the scaling factors that should be used for forward and inverse transforms. + + + + Initializes a new instance of the class. + + The device context used to create the FFT. + Information that describes the shape of the FFT data as well as the scaling factors that should be used for forward and inverse transforms. + Flag affecting the behavior of the FFT. + + + + Attaches buffers to an FFT context and performs any required precomputations. + + + The buffers must be no smaller than the corresponding buffer sizes returned by D3DX11CreateFFT*(). Temporary buffers can be shared between multiple contexts, though care should be taken not to concurrently execute multiple FFTs which share temp buffers. + + Temporary buffers to attach. + Buffers to hold precomputed data. + Returns one of the return codes described in the topic {{Direct3D 11 Return Codes}}. + HRESULT ID3DX11FFT::AttachBuffersAndPrecompute([In] int NumTempBuffers,[In, Buffer] const ID3D11UnorderedAccessView** ppTempBuffers,[In] int NumPrecomputeBuffers,[In, Buffer] const ID3D11UnorderedAccessView** ppPrecomputeBufferSizes) + + + + Creates a new one-dimensional complex FFT. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + an interface reference. + HRESULT D3DX11CreateFFT1DComplex([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates a new one-dimensional complex FFT. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Flag affecting the behavior of the FFT, can be 0 or a combination of flags from . + an interface reference. + HRESULT D3DX11CreateFFT1DComplex([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates a new one-dimensional real FFT. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + an interface reference. + HRESULT D3DX11CreateFFT1DReal([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates a new one-dimensional real FFT. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Flag affecting the behavior of the FFT, can be 0 or a combination of flags from . + an interface reference. + HRESULT D3DX11CreateFFT1DReal([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates a new two-dimensional complex FFT. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Length of the second dimension of the FFT. + an interface reference. + HRESULT D3DX11CreateFFT1DReal([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates a new two-dimensional complex FFT. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Length of the second dimension of the FFT. + Flag affecting the behavior of the FFT, can be 0 or a combination of flags from . + an interface reference. + HRESULT D3DX11CreateFFT1DReal([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates a new two-dimensional real FFT. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Length of the second dimension of the FFT. + an interface reference. + HRESULT D3DX11CreateFFT1DReal([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates a new two-dimensional real FFT. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Length of the second dimension of the FFT. + Flag affecting the behavior of the FFT, can be 0 or a combination of flags from . + an interface reference. + HRESULT D3DX11CreateFFT1DReal([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates a new three-dimensional complex FFT. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Length of the second dimension of the FFT. + Length of the third dimension of the FFT. + an interface reference. + HRESULT D3DX11CreateFFT1DReal([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates a new three-dimensional complex FFT. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Length of the second dimension of the FFT. + Length of the third dimension of the FFT. + Flag affecting the behavior of the FFT, can be 0 or a combination of flags from . + an interface reference. + HRESULT D3DX11CreateFFT1DReal([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates a new three-dimensional real FFT. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Length of the second dimension of the FFT. + Length of the third dimension of the FFT. + an interface reference. + HRESULT D3DX11CreateFFT1DReal([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates a new three-dimensional real FFT. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Length of the second dimension of the FFT. + Length of the third dimension of the FFT. + Flag affecting the behavior of the FFT, can be 0 or a combination of flags from . + an interface reference. + HRESULT D3DX11CreateFFT1DReal([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Sets the scale used for forward transforms. + + + SetForwardScale sets the scale used by . + + The scale to use for forward transforms. Setting ForwardScale to 0 causes the default values of 1 to be used. + Returns one of the return codes described in the topic {{Direct3D 11 Return Codes}}. + HRESULT ID3DX11FFT::SetForwardScale([None] float ForwardScale) + + + + Gets the scale for forward transforms. + + Scale for forward transforms. + float ID3DX11FFT::GetForwardScale() + + + + Sets the scale used for inverse transforms. + + + SetInverseScale sets the scale used by . + + Scale used for inverse transforms. Setting InverseScale to 0 causes the default value of 1/N to be used, where N is the product of the transformed dimension lengths. + Returns one of the return codes described in the topic {{Direct3D 11 Return Codes}}. + HRESULT ID3DX11FFT::SetInverseScale([None] float InverseScale) + + + + Get the scale for inverse transforms. + + Scale for inverse transforms. + float ID3DX11FFT::GetInverseScale() + + + + Attaches buffers to an FFT context and performs any required precomputations. + + + The buffers must be no smaller than the corresponding buffer sizes returned by D3DX11CreateFFT*(). Temporary buffers can be shared between multiple contexts, though care should be taken not to concurrently execute multiple FFTs which share temp buffers. + + Number of buffers in ppTempBuffers. + Temporary buffers to attach. + Number of buffers in ppPrecomputeBufferSizes. + Buffers to hold precomputed data. + Returns one of the return codes described in the topic {{Direct3D 11 Return Codes}}. + HRESULT ID3DX11FFT::AttachBuffersAndPrecompute([In] int NumTempBuffers,[In, Buffer] const ID3D11UnorderedAccessView** ppTempBuffers,[In] int NumPrecomputeBuffers,[In, Buffer] const ID3D11UnorderedAccessView** ppPrecomputeBufferSizes) + + + + Performs a forward FFT. + + + ForwardTransform can be called after buffers have been attached to the context using . The combination of pInputBuffer and *ppOuputBuffer can be one of the temp buffers. The format of complex data is interleaved components (for example, (Real0, Imag0), (Real1, Imag1) ... , and so on). Data is stored in row major order. + + Pointer to onto the input buffer. + Pointer to a reference. If *ppOutputBuffer is NULL, the computation will switch between temp buffers; in addition, the last buffer written to is stored at *ppOutputBuffer. Otherwise, *ppOutputBuffer is used as the output buffer (which might incur an extra copy). + Returns one of the return codes described in the topic {{Direct3D 11 Return Codes}}. + HRESULT ID3DX11FFT::ForwardTransform([In] const ID3D11UnorderedAccessView* pInputBuffer,[InOut] ID3D11UnorderedAccessView** ppOutputBuffer) + + + + Performs an inverse FFT. + + Pointer to onto the input buffer. + Pointer to a reference. If *ppOutput is NULL, then the computation will switch between temp buffers; in addition, the last buffer written to is stored at *ppOutput. Otherwise, *ppOutput is used as the output buffer (which might incur an extra copy). + Returns one of the return codes described in the topic {{Direct3D 11 Return Codes}}. + HRESULT ID3DX11FFT::InverseTransform([In] const ID3D11UnorderedAccessView* pInputBuffer,[InOut] ID3D11UnorderedAccessView** ppOutputBuffer) + + + + Gets the buffer requirements. + + The buffer requirements. + + + + Gets the scale for forward transforms. + + float ID3DX11FFT::GetForwardScale() + + + + Get the scale for inverse transforms. + + float ID3DX11FFT::GetInverseScale() + + + + Type of data contained in an input slot. + + + Use these values to specify the type of data for a particular input element (see ) of an input-layout object. + + D3D11_INPUT_CLASSIFICATION + + + + Input data is per-vertex data. + + D3D11_INPUT_PER_VERTEX_DATA + + + + Input data is per-instance data. + + D3D11_INPUT_PER_INSTANCE_DATA + + + + Determines the fill mode to use when rendering triangles. + + + This enumeration is part of a rasterizer-state object description (see ). + + D3D11_FILL_MODE + + + + Draw lines connecting the vertices. Adjacent vertices are not drawn. + + D3D11_FILL_WIREFRAME + + + + Fill the triangles formed by the vertices. Adjacent vertices are not drawn. + + D3D11_FILL_SOLID + + + + Indicates triangles facing a particular direction are not drawn. + + + This enumeration is part of a rasterizer-state object description (see ). + + D3D11_CULL_MODE + + + + Always draw all triangles. + + D3D11_CULL_NONE + + + + Do not draw triangles that are front-facing. + + D3D11_CULL_FRONT + + + + Do not draw triangles that are back-facing. + + D3D11_CULL_BACK + + + + Identifies the type of resource being used. + + + This enumeration is used in . + + D3D11_RESOURCE_DIMENSION + + + + Resource is of unknown type. + + D3D11_RESOURCE_DIMENSION_UNKNOWN + + + + Resource is a buffer. + + D3D11_RESOURCE_DIMENSION_BUFFER + + + + Resource is a 1D texture. + + D3D11_RESOURCE_DIMENSION_TEXTURE1D + + + + Resource is a 2D texture. + + D3D11_RESOURCE_DIMENSION_TEXTURE2D + + + + Resource is a 3D texture. + + D3D11_RESOURCE_DIMENSION_TEXTURE3D + + + + Specifies how to access a resource used in a depth-stencil view. + + + This enumeration is used in to create a depth-stencil view. + + D3D11_DSV_DIMENSION + + + + D3D11_DSV_DIMENSION_UNKNOWN is not a valid value for and is not used. + + D3D11_DSV_DIMENSION_UNKNOWN + + + + The resource will be accessed as a 1D texture. + + D3D11_DSV_DIMENSION_TEXTURE1D + + + + The resource will be accessed as an array of 1D textures. + + D3D11_DSV_DIMENSION_TEXTURE1DARRAY + + + + The resource will be accessed as a 2D texture. + + D3D11_DSV_DIMENSION_TEXTURE2D + + + + The resource will be accessed as an array of 2D textures. + + D3D11_DSV_DIMENSION_TEXTURE2DARRAY + + + + The resource will be accessed as a 2D texture with multisampling. + + D3D11_DSV_DIMENSION_TEXTURE2DMS + + + + The resource will be accessed as an array of 2D textures with multisampling. + + D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY + + + + These flags identify the type of resource that will be viewed as a render target. + + + This enumeration is used in to create a render-target view. + + D3D11_RTV_DIMENSION + + + + Do not use this value, as it will cause to fail. + + D3D11_RTV_DIMENSION_UNKNOWN + + + + The resource will be accessed as a buffer. + + D3D11_RTV_DIMENSION_BUFFER + + + + The resource will be accessed as a 1D texture. + + D3D11_RTV_DIMENSION_TEXTURE1D + + + + The resource will be accessed as an array of 1D textures. + + D3D11_RTV_DIMENSION_TEXTURE1DARRAY + + + + The resource will be accessed as a 2D texture. + + D3D11_RTV_DIMENSION_TEXTURE2D + + + + The resource will be accessed as an array of 2D textures. + + D3D11_RTV_DIMENSION_TEXTURE2DARRAY + + + + The resource will be accessed as a 2D texture with multisampling. + + D3D11_RTV_DIMENSION_TEXTURE2DMS + + + + The resource will be accessed as an array of 2D textures with multisampling. + + D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY + + + + The resource will be accessed as a 3D texture. + + D3D11_RTV_DIMENSION_TEXTURE3D + + + + Unordered-access view options. + + + This enumeration is used by a unordered access-view description (see ). + + D3D11_UAV_DIMENSION + + + + The view type is unknown. + + D3D11_UAV_DIMENSION_UNKNOWN + + + + View the resource as a buffer. + + D3D11_UAV_DIMENSION_BUFFER + + + + View the resource as a 1D texture. + + D3D11_UAV_DIMENSION_TEXTURE1D + + + + View the resource as a 1D texture array. + + D3D11_UAV_DIMENSION_TEXTURE1DARRAY + + + + View the resource as a 2D texture. + + D3D11_UAV_DIMENSION_TEXTURE2D + + + + View the resource as a 2D texture array. + + D3D11_UAV_DIMENSION_TEXTURE2DARRAY + + + + View the resource as a 3D texture array. + + D3D11_UAV_DIMENSION_TEXTURE3D + + + + Identifies expected resource use during rendering. The usage directly reflects whether a resource is accessible by the CPU and/or the GPU. + + + An application identifies the way a resource is intended to be used (its usage) in a resource description. There are several structures for creating resources including: , , , . Differences between Direct3D 9 and Direct3D 10/11: In Direct3D 9, you specify the type of memory a resource should be created in at resource creation time (using D3DPOOL). It was an application's job to decide what memory pool would provide the best combination of functionality and performance. In Direct3D 10/11, an application no longer specifies what type of memory (the pool) to create a resource in. Instead, you specify the intended usage of the resource, and let the runtime (in concert with the driver and a memory manager) choose the type of memory that will achieve the best performance. ? Resource Usage Restrictions Each usage dictates a tradeoff between functionality and performance. In general, resource accessing is accomplished with the following APIs. CPU access is done with . GPU access is done with , , or . Use the following table to choose the usage that best describes how the resource will need to be accessed by the CPU and/or the GPU. Of course, there will be performance tradeoffs. Resource UsageDefaultDynamicImmutableStaging GPU-Readyesyes1yesyes1, 2 GPU-Writeyes1yes1, 2 CPU-Readyes1, 2 CPU-Writeyesyes1, 2 ? 1 - This is restricted to , and . 2 - Cannot be a depth-stencil buffer or a multisampled render target. Resource Bind Options To maximize performance, not all resource usage options can be used as input or output resources to the pipeline. This table identifies these limitations. Resource Can Be Bound AsDefaultDynamicImmutableStaging Input to a Stageyes3yes4yes Output from a Stageyes3 ? 3 - If bound as an input and an output using different views, each view must use different subresources. 4 - The resource can only be created with a single subresource. The resource cannot be a texture array. The resource cannot be a mipmap chain. + + D3D11_USAGE + + + + A resource that requires read and write access by the GPU. This is likely to be the most common usage choice. + + D3D11_USAGE_DEFAULT + + + + A resource that can only be read by the GPU. It cannot be written by the GPU, and cannot be accessed at all by the CPU. This type of resource must be initialized when it is created, since it cannot be changed after creation. + + D3D11_USAGE_IMMUTABLE + + + + A resource that is accessible by both the GPU (read only) and the CPU (write only). A dynamic resource is a good choice for a resource that will be updated by the CPU at least once per frame. To update a dynamic resource, use a Map method. + + D3D11_USAGE_DYNAMIC + + + + A resource that supports data transfer (copy) from the GPU to the CPU. + + D3D11_USAGE_STAGING + + + + Identifies how to bind a resource to the pipeline. + + + In general, binding flags can be combined using a logical OR (except the constant-buffer flag); however, you should use a single flag to allow the device to optimize the resource usage. This enumeration is used by a: {{Buffer description}} when creating a buffer. Texture description when creating a texture (see or or ). A shader-resource buffer is NOT a constant buffer; rather, it is a texture or buffer resource that is bound to a shader, that contains texture or buffer data (it is not limited to a single element type in the buffer). A shader-resource buffer is created with the D3D11_BIND_SHADER_RESOURCE flag and is bound to the pipeline using one of these APIs: , , or . Furthermore, a shader-resource buffer cannot use the flag. + + D3D11_BIND_FLAG + + + + Bind a buffer as a vertex buffer to the input-assembler stage. + + D3D11_BIND_VERTEX_BUFFER + + + + Bind a buffer as an index buffer to the input-assembler stage. + + D3D11_BIND_INDEX_BUFFER + + + + Bind a buffer as a constant buffer to a shader stage; this flag may NOT be combined with any other bind flag. + + D3D11_BIND_CONSTANT_BUFFER + + + + Bind a buffer or texture to a shader stage; this flag cannot be used with the flag. + + D3D11_BIND_SHADER_RESOURCE + + + + Bind an output buffer for the stream-output stage. + + D3D11_BIND_STREAM_OUTPUT + + + + Bind a texture as a render target for the output-merger stage. + + D3D11_BIND_RENDER_TARGET + + + + Bind a texture as a depth-stencil target for the output-merger stage. + + D3D11_BIND_DEPTH_STENCIL + + + + Bind an {{unordered access}} resource. + + D3D11_BIND_UNORDERED_ACCESS + + + + None. + + None + + + + Specifies the types of CPU access allowed for a resource. + + + This enumeration is used in , , , . Applications may combine one or more of these flags with a logical OR. When possible, create resources with no CPU access flags, as this enables better resource optimiztion. + + D3D11_CPU_ACCESS_FLAG + + + + The resource is to be mappable so that the CPU can change its contents. Resources created with this flag cannot be set as outputs of the pipeline and must be created with either dynamic or staging usage (see ). + + D3D11_CPU_ACCESS_WRITE + + + + The resource is to be mappable so that the CPU can read its contents. Resources created with this flag cannot be set as either inputs or outputs to the pipeline and must be created with staging usage (see ). + + D3D11_CPU_ACCESS_READ + + + + None. + + None + + + + Identifies other, less common options for resources. + + + This enumeration is used in , , , . These flags can be combined by bitwise OR. + + D3D11_RESOURCE_MISC_FLAG + + + + Enables mipmap generation using on a texture resource. The resource must be created with the {{bind flags}} that specify that the resource is a render target and a shader resource. + + D3D11_RESOURCE_MISC_GENERATE_MIPS + + + + Enables resource data sharing between two or more Direct3D devices. The only resources that can be shared are 2D non-mipmapped textures. D3D11_RESOURCE_MISC_SHARED and D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX are mutually exclusive. WARP and REF devices do not support shared resources. Attempting to create a resource with this flag on either a WARP or REF device will cause the create method to return an E_OUTOFMEMORY error code. + + D3D11_RESOURCE_MISC_SHARED + + + + Enables a resource to be a cube texture created from a Texture2DArray that contains 6 textures. + + D3D11_RESOURCE_MISC_TEXTURECUBE + + + + Enables instancing of GPU-generated content. + + D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS + + + + Enables a resource as a {{byte address buffer}}. + + D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS + + + + Enables a resource as a {{structured buffer}}. + + D3D11_RESOURCE_MISC_BUFFER_STRUCTURED + + + + Enables a resource with mipmap clamping for use with . + + D3D11_RESOURCE_MISC_RESOURCE_CLAMP + + + + Enables the resource created to be synchronized using the and APIs. The following Direct3D 11 resource creation APIs, that take D3D11_RESOURCE_MISC_FLAG parameters, have been extended to support the new flag. If any of the above methods is called with the D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX flag set, the interface returned will support the interface. The IDXGIKeyedMutex interface can be acquired from the resource using {{IUnknown::QueryInterface}}. The IDXGIKeyedMutex interface implements the and APIs to synchronize access to the surface. The device creating the surface, and any other device opening the surface (using {{OpenSharedResource}}) is required to call IDXGIKeyedMutex::AcquireSync before any rendering commands to the surface, and IDXGIKeyedMutex::ReleaseSync when it is done rendering. D3D11_RESOURCE_MISC_SHARED and D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX are mutually exclusive. WARP and REF devices do not support shared resources. Attempting to create a resource with this flag on either a WARP or REF device will cause the create method to return an E_OUTOFMEMORY error code. + + D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX + + + + Enables a resource compatible with GDI. The D3D11_RESOURCE_MISC_GDI_COMPATIBLE flag is required on surfaces that will be used with GDI. Setting the D3D11_RESOURCE_MISC_GDI_COMPATIBLE flag allows GDI rendering on the surface via GetDC. + + + D3D11_RESOURCE_MISC_GDI_COMPATIBLE + + + + None. + + None + + + + Identifies a resource to be accessed for reading and writing by the CPU. Applications may combine one or more of these flags. + + + This enumeration is used in . These remarks are divided into the following topics: {{Meaning of D3D11_MAP_WRITE_NO_OVERWRITE}} {{Common Usage of D3D11_MAP_WRITE_DISCARD with D3D11_MAP_WRITE_NO_OVERWRITE}} Meaning of D3D11_MAP_WRITE_NO_OVERWRITE D3D11_MAP_WRITE_NO_OVERWRITE signifies that the application promises not to write to data that the input assembler (IA) stage is using. In exchange, the GPU allows the application to write to other parts of the same buffer. The application must ensure that it does not write over any data in use by the IA stage. For example, consider the buffer illustrated in the following diagram. If a Draw call has been issued that uses vertices 4-6, then an application that calls Map on this buffer must ensure that it does not write to the vertices that the Draw call will access during rendering. ? Diagram of a buffer that includes vertices in different stages of utilization ? However, ensuring this can be difficult, because the GPU is often many frames behind the CPU in terms of which frame it is currently processing. Keeping track of which sections of a resource are being used because of calls made 2 to 5 frames ago is difficult and error-prone. Because of this, it is recommended that applications only write to the uninitialized portions of a resource when using D3D11_MAP_WRITE_NO_OVERWRITE. Common Usage of D3D11_MAP_WRITE_DISCARD with D3D11_MAP_WRITE_NO_OVERWRITE D3D11_MAP_WRITE_DISCARD and D3D11_MAP_WRITE_NO_OVERWRITE are normally used in conjunction with dynamic index/vertex buffers. D3D11_MAP_WRITE_DISCARD can also be used with dynamic textures. However, D3D11_MAP_WRITE_NO_OVERWRITE cannot be used with dynamic textures. A common use of these two flags involves filling dynamic index/vertex buffers with geometry that can be seen from the camera's current position. The first time that data is entered into the buffer on a given frame, Map is called with D3D11_MAP_WRITE_DISCARD; doing so invalidates the previous contents of the buffer. The buffer is then filled with all available data. Subsequent writes to the buffer within the same frame should use D3D11_MAP_WRITE_NO_OVERWRITE. This will enable the CPU to access a resource that is potentially being used by the GPU as long as the restrictions described previously are respected. + + D3D11_MAP + + + + Resource is mapped for reading. The resource must have been created with read access (see ). + + D3D11_MAP_READ + + + + Resource is mapped for writing. The resource must have been created with write access (see ). + + D3D11_MAP_WRITE + + + + Resource is mapped for reading and writing. The resource must have been created with read and write access (see {{D3D11_CPU_ACCESS_READ and D3D11_CPU_ACCESS_WRITE}}). + + D3D11_MAP_READ_WRITE + + + + Resource is mapped for writing; the previous contents of the resource will be undefined. The resource must have been created with write access and dynamic usage (See and ). + + D3D11_MAP_WRITE_DISCARD + + + + Resource is mapped for writing; the existing contents of the resource cannot be overwritten (see Remarks). This flag is only valid on vertex and index buffers. The resource must have been created with write access (see ). Cannot be used on a resource created with the flag. + + D3D11_MAP_WRITE_NO_OVERWRITE + + + + Specifies how the CPU should respond when an application calls the method on a resource that is being used by the GPU. + + + This enumeration is used by . D3D11_MAP_FLAG_DO_NOT_WAIT cannot be used with or {{D3D11_MAP_WRITE_NOOVERWRITE}}. + + D3D11_MAP_FLAG + + + + Specifies that should return DXGI_ERROR_WAS_STILL_DRAWING when the GPU blocks the CPU from accessing a resource. For more information about this error code, see . + + D3D11_MAP_FLAG_DO_NOT_WAIT + + + + None. + + None + + + + Specifies the parts of the depth stencil to clear. + + + These flags are used when calling ; the flags can be combined with a bitwise OR. + + D3D11_CLEAR_FLAG + + + + Clear the depth buffer. + + D3D11_CLEAR_DEPTH + + + + Clear the stencil buffer. + + D3D11_CLEAR_STENCIL + + + + Comparison options. + + + A comparison option determines whether how the runtime compares source (new) data against destination (existing) data before storing the new data. The comparison option is declared in a description before an object is created. The API allows you to set a comparison option for a depth-stencil buffer (see ), depth-stencil operations (see ), or sampler state (see ). + + D3D11_COMPARISON_FUNC + + + + Never pass the comparison. + + D3D11_COMPARISON_NEVER + + + + If the source data is less than the destination data, the comparison passes. + + D3D11_COMPARISON_LESS + + + + If the source data is equal to the destination data, the comparison passes. + + D3D11_COMPARISON_EQUAL + + + + If the source data is less than or equal to the destination data, the comparison passes. + + D3D11_COMPARISON_LESS_EQUAL + + + + If the source data is greater than the destination data, the comparison passes. + + D3D11_COMPARISON_GREATER + + + + If the source data is not equal to the destination data, the comparison passes. + + D3D11_COMPARISON_NOT_EQUAL + + + + If the source data is greater than or equal to the destination data, the comparison passes. + + D3D11_COMPARISON_GREATER_EQUAL + + + + Always pass the comparison. + + D3D11_COMPARISON_ALWAYS + + + + Identify the portion of a depth-stencil buffer for writing depth data. + + D3D11_DEPTH_WRITE_MASK + + + + Turn off writes to the depth-stencil buffer. + + D3D11_DEPTH_WRITE_MASK_ZERO + + + + Turn on writes to the depth-stencil buffer. + + D3D11_DEPTH_WRITE_MASK_ALL + + + + The stencil operations that can be performed during depth-stencil testing. + + D3D11_STENCIL_OP + + + + Keep the existing stencil data. + + D3D11_STENCIL_OP_KEEP + + + + Set the stencil data to 0. + + D3D11_STENCIL_OP_ZERO + + + + Set the stencil data to the reference value set by calling . + + D3D11_STENCIL_OP_REPLACE + + + + Increment the stencil value by 1, and clamp the result. + + D3D11_STENCIL_OP_INCR_SAT + + + + Decrement the stencil value by 1, and clamp the result. + + D3D11_STENCIL_OP_DECR_SAT + + + + Invert the stencil data. + + D3D11_STENCIL_OP_INVERT + + + + Increment the stencil value by 1, and wrap the result if necessary. + + D3D11_STENCIL_OP_INCR + + + + Increment the stencil value by 1, and wrap the result if necessary. + + D3D11_STENCIL_OP_DECR + + + + Blend options. A blend option identifies the data source and an optional pre-blend operation. + + + Blend operations are specified in a {{blend description}}. + + D3D11_BLEND + + + + The data source is the color black (0, 0, 0, 0). No pre-blend operation. + + D3D11_BLEND_ZERO + + + + The data source is the color white (1, 1, 1, 1). No pre-blend operation. + + D3D11_BLEND_ONE + + + + The data source is color data (RGB) from a pixel shader. No pre-blend operation. + + D3D11_BLEND_SRC_COLOR + + + + The data source is color data (RGB) from a pixel shader. The pre-blend operation inverts the data, generating 1 - RGB. + + D3D11_BLEND_INV_SRC_COLOR + + + + The data source is alpha data (A) from a pixel shader. No pre-blend operation. + + D3D11_BLEND_SRC_ALPHA + + + + The data source is alpha data (A) from a pixel shader. The pre-blend operation inverts the data, generating 1 - A. + + D3D11_BLEND_INV_SRC_ALPHA + + + + The data source is alpha data from a rendertarget. No pre-blend operation. + + D3D11_BLEND_DEST_ALPHA + + + + The data source is alpha data from a rendertarget. The pre-blend operation inverts the data, generating 1 - A. + + D3D11_BLEND_INV_DEST_ALPHA + + + + The data source is color data from a rendertarget. No pre-blend operation. + + D3D11_BLEND_DEST_COLOR + + + + The data source is color data from a rendertarget. The pre-blend operation inverts the data, generating 1 - RGB. + + D3D11_BLEND_INV_DEST_COLOR + + + + The data source is alpha data from a pixel shader. The pre-blend operation clamps the data to 1 or less. + + + D3D11_BLEND_SRC_ALPHA_SAT + + + + The data source is the blend factor set with . No pre-blend operation. + + D3D11_BLEND_BLEND_FACTOR + + + + The data source is the blend factor set with . The pre-blend operation inverts the blend factor, generating 1 - blend_factor. + + D3D11_BLEND_INV_BLEND_FACTOR + + + + The data sources are both color data output by a pixel shader. There is no pre-blend operation. This options supports dual-source color blending. + + D3D11_BLEND_SRC1_COLOR + + + + The data sources are both color data output by a pixel shader. The pre-blend operation inverts the data, generating 1 - RGB. This options supports dual-source color blending. + + D3D11_BLEND_INV_SRC1_COLOR + + + + The data sources are alpha data output by a pixel shader. There is no pre-blend operation. This options supports dual-source color blending. + + D3D11_BLEND_SRC1_ALPHA + + + + The data sources are alpha data output by a pixel shader. The pre-blend operation inverts the data, generating 1 - A. This options supports dual-source color blending. + + D3D11_BLEND_INV_SRC1_ALPHA + + + + RGB or alpha blending operation. + + + The runtime implements RGB blending and alpha blending separately. Therefore, blend state requires separate blend operations for RGB data and alpha data. These blend operations are specified in a {{blend description}}. The two sources?Source 1, called SrcBlend and SrcBlendAlpha, and Source 2, called DestBlend and DestBlendAlpha?are shown in the blending block diagram. + + D3D11_BLEND_OP + + + + Add source 1 and source 2. + + D3D11_BLEND_OP_ADD + + + + Subtract source 1 from source 2. + + D3D11_BLEND_OP_SUBTRACT + + + + Subtract source 2 from source 1. + + D3D11_BLEND_OP_REV_SUBTRACT + + + + Find the minimum of source 1 and source 2. + + D3D11_BLEND_OP_MIN + + + + Find the maximum of source 1 and source 2. + + D3D11_BLEND_OP_MAX + + + + Identify which components of each pixel of a render target are writable during blending. + + + These flags can be combined with a bitwise OR. + + D3D11_COLOR_WRITE_ENABLE + + + + Allow data to be stored in the red component. + + D3D11_COLOR_WRITE_ENABLE_RED + + + + Allow data to be stored in the green component. + + D3D11_COLOR_WRITE_ENABLE_GREEN + + + + Allow data to be stored in the blue component. + + D3D11_COLOR_WRITE_ENABLE_BLUE + + + + Allow data to be stored in the alpha component. + + D3D11_COLOR_WRITE_ENABLE_ALPHA + + + + Allow data to be stored in all components. + + D3D11_COLOR_WRITE_ENABLE_ALL + + + + The different faces of a cube texture. + + D3D11_TEXTURECUBE_FACE + + + + Positive X face. + + D3D11_TEXTURECUBE_FACE_POSITIVE_X + + + + Negative X face. + + D3D11_TEXTURECUBE_FACE_NEGATIVE_X + + + + Positive Y face. + + D3D11_TEXTURECUBE_FACE_POSITIVE_Y + + + + Negative Y face. + + D3D11_TEXTURECUBE_FACE_NEGATIVE_Y + + + + Positive Z face. + + D3D11_TEXTURECUBE_FACE_POSITIVE_Z + + + + Negative Z face. + + D3D11_TEXTURECUBE_FACE_NEGATIVE_Z + + + + Identifies how to bind a raw-buffer resource to the pipeline. + + + This enumeration is used by + + D3D11_BUFFEREX_SRV_FLAG + + + + Bind a raw buffer to the input-assembler stage. + + D3D11_BUFFEREX_SRV_FLAG_RAW + + + + None. + + None + + + + Depth-stencil view options. + + + This enumeration is used by . Limiting a depth-stencil buffer to read-only access allows more than one depth-stencil view to be bound to the pipeline simultaneously, since it is not possible to have a read/write conflicts between separate views. + + D3D11_DSV_FLAG + + + + Indicates that depth values are read only. + + D3D11_DSV_READ_ONLY_DEPTH + + + + Indicates that stencil values are read only. + + D3D11_DSV_READ_ONLY_STENCIL + + + + None. + + None + + + + Unordered-access-view buffer options. + + D3D11_BUFFER_UAV_FLAG + + + + Resource contains raw, unstructured data. Requires the UAV format to be DXGI_FORMAT_R32_TYPELESS. + + D3D11_BUFFER_UAV_FLAG_RAW + + + + Allow data to be appended to the end of the buffer. D3D11_BUFFER_UAV_FLAG_APPEND flag must also be used for any view that will be used as a {{AppendStructuredBuffer}} or a {{ConsumeStructuredBuffer}}. Requires the UAV format to be DXGI_FORMAT_UNKNOWN. + + D3D11_BUFFER_UAV_FLAG_APPEND + + + + Adds a counter to the unordered-access-view buffer. D3D11_BUFFER_UAV_FLAG_COUNTER can only be used on a UAV that is a {{RWStructuredBuffer}} and it enables the functionality needed for the {{IncrementCounter}} and {{DecrementCounter}} methods in HLSL. Requires the UAV format to be DXGI_FORMAT_UNKNOWN. + + D3D11_BUFFER_UAV_FLAG_COUNTER + + + + None. + + None + + + + Filtering options during texture sampling. + + + During texture sampling, one or more texels are read and combined (this is calling filtering) to produce a single value. Point sampling reads a single texel while linear sampling reads two texels (endpoints) and linearly interpolates a third value between the endpoints. HLSL texture-sampling functions also support comparison filtering during texture sampling. Comparison filtering compares each sampled texel against a comparison value. The boolean result is blended the same way that normal texture filtering is blended. You can use HLSL intrinsic texture-sampling functions that implement texture filtering only or companion functions that use texture filtering with comparison filtering. Texture Sampling FunctionTexture Sampling Function with Comparison Filtering samplesamplecmp or samplecmplevelzero ? Comparison filters only work with textures that have the following DXGI formats: R32_FLOAT_X8X24_TYPELESS, R32_FLOAT, R24_UNORM_X8_TYPELESS, R16_UNORM. + + D3D11_FILTER + + + + Use point sampling for minification, magnification, and mip-level sampling. + + D3D11_FILTER_MIN_MAG_MIP_POINT + + + + Use point sampling for minification and magnification; use linear interpolation for mip-level sampling. + + D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR + + + + Use point sampling for minification; use linear interpolation for magnification; use point sampling for mip-level sampling. + + D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT + + + + Use point sampling for minification; use linear interpolation for magnification and mip-level sampling. + + D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR + + + + Use linear interpolation for minification; use point sampling for magnification and mip-level sampling. + + D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT + + + + Use linear interpolation for minification; use point sampling for magnification; use linear interpolation for mip-level sampling. + + D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR + + + + Use linear interpolation for minification and magnification; use point sampling for mip-level sampling. + + D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT + + + + Use linear interpolation for minification, magnification, and mip-level sampling. + + D3D11_FILTER_MIN_MAG_MIP_LINEAR + + + + Use anisotropic interpolation for minification, magnification, and mip-level sampling. + + D3D11_FILTER_ANISOTROPIC + + + + Use point sampling for minification, magnification, and mip-level sampling. Compare the result to the comparison value. + + D3D11_FILTER_COMPARISON_MIN_MAG_MIP_POINT + + + + Use point sampling for minification and magnification; use linear interpolation for mip-level sampling. Compare the result to the comparison value. + + D3D11_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR + + + + Use point sampling for minification; use linear interpolation for magnification; use point sampling for mip-level sampling. Compare the result to the comparison value. + + D3D11_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT + + + + Use point sampling for minification; use linear interpolation for magnification and mip-level sampling. Compare the result to the comparison value. + + D3D11_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR + + + + Use linear interpolation for minification; use point sampling for magnification and mip-level sampling. Compare the result to the comparison value. + + D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT + + + + Use linear interpolation for minification; use point sampling for magnification; use linear interpolation for mip-level sampling. Compare the result to the comparison value. + + D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR + + + + Use linear interpolation for minification and magnification; use point sampling for mip-level sampling. Compare the result to the comparison value. + + D3D11_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT + + + + Use linear interpolation for minification, magnification, and mip-level sampling. Compare the result to the comparison value. + + D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR + + + + Use anisotropic interpolation for minification, magnification, and mip-level sampling. Compare the result to the comparison value. + + D3D11_FILTER_COMPARISON_ANISOTROPIC + + + + Types of magnification or minification sampler filters. + + D3D11_FILTER_TYPE + + + + Point filtering used as a texture magnification or minification filter. The texel with coordinates nearest to the desired pixel value is used. The texture filter to be used between mipmap levels is nearest-point mipmap filtering. The rasterizer uses the color from the texel of the nearest mipmap texture. + + D3D11_FILTER_TYPE_POINT + + + + Bilinear interpolation filtering used as a texture magnification or minification filter. A weighted average of a 2 x 2 area of texels surrounding the desired pixel is used. The texture filter to use between mipmap levels is trilinear mipmap interpolation. The rasterizer linearly interpolates pixel color, using the texels of the two nearest mipmap textures. + + D3D11_FILTER_TYPE_LINEAR + + + + Identify a technique for resolving texture coordinates that are outside of the boundaries of a texture. + + D3D11_TEXTURE_ADDRESS_MODE + + + + Tile the texture at every (u,v) integer junction. For example, for u values between 0 and 3, the texture is repeated three times. + + D3D11_TEXTURE_ADDRESS_WRAP + + + + Flip the texture at every (u,v) integer junction. For u values between 0 and 1, for example, the texture is addressed normally; between 1 and 2, the texture is flipped (mirrored); between 2 and 3, the texture is normal again; and so on. + + D3D11_TEXTURE_ADDRESS_MIRROR + + + + Texture coordinates outside the range [0.0, 1.0] are set to the texture color at 0.0 or 1.0, respectively. + + D3D11_TEXTURE_ADDRESS_CLAMP + + + + Texture coordinates outside the range [0.0, 1.0] are set to the border color specified in or HLSL code. + + D3D11_TEXTURE_ADDRESS_BORDER + + + + Similar to D3D11_TEXTURE_ADDRESS_MIRROR and D3D11_TEXTURE_ADDRESS_CLAMP. Takes the absolute value of the texture coordinate (thus, mirroring around 0), and then clamps to the maximum value. + + D3D11_TEXTURE_ADDRESS_MIRROR_ONCE + + + + Which resources are supported for a given format and given device (see and ). + + D3D11_FORMAT_SUPPORT + + + + Buffer resources supported. + + D3D11_FORMAT_SUPPORT_BUFFER + + + + Vertex buffers supported. + + D3D11_FORMAT_SUPPORT_IA_VERTEX_BUFFER + + + + Index buffers supported. + + D3D11_FORMAT_SUPPORT_IA_INDEX_BUFFER + + + + Streaming output buffers supported. + + D3D11_FORMAT_SUPPORT_SO_BUFFER + + + + 1D texture resources supported. + + D3D11_FORMAT_SUPPORT_TEXTURE1D + + + + 2D texture resources supported. + + D3D11_FORMAT_SUPPORT_TEXTURE2D + + + + 3D texture resources supported. + + D3D11_FORMAT_SUPPORT_TEXTURE3D + + + + Cube texture resources supported. + + D3D11_FORMAT_SUPPORT_TEXTURECUBE + + + + The intrinsic HLSL function load is supported. + + D3D11_FORMAT_SUPPORT_SHADER_LOAD + + + + The intrinsic HLSL functions sample supported. + + D3D11_FORMAT_SUPPORT_SHADER_SAMPLE + + + + The intrinsic HLSL functions samplecmp and samplecmplevelzero are supported. + + D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON + + + + Reserved. + + D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_MONO_TEXT + + + + Mipmaps are supported. + + D3D11_FORMAT_SUPPORT_MIP + + + + Automatic generation of mipmaps is supported. + + D3D11_FORMAT_SUPPORT_MIP_AUTOGEN + + + + Rendertargets are supported. + + D3D11_FORMAT_SUPPORT_RENDER_TARGET + + + + Blend operations supported. + + D3D11_FORMAT_SUPPORT_BLENDABLE + + + + Depth stencils supported. + + D3D11_FORMAT_SUPPORT_DEPTH_STENCIL + + + + CPU locking supported. + + D3D11_FORMAT_SUPPORT_CPU_LOCKABLE + + + + Multisampling resolution supported. + + D3D11_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE + + + + Format can be displayed on screen. + + D3D11_FORMAT_SUPPORT_DISPLAY + + + + Format cannot be cast to another format. + + D3D11_FORMAT_SUPPORT_CAST_WITHIN_BIT_LAYOUT + + + + Format can be used as a multisampled rendertarget. + + D3D11_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET + + + + Format can be used as a multisampled texture and read into a shader with the HLSL load function. + + D3D11_FORMAT_SUPPORT_MULTISAMPLE_LOAD + + + + Format can be used with the HLSL gather function. This value is available in DirectX 10.1 or higher. + + D3D11_FORMAT_SUPPORT_SHADER_GATHER + + + + Format supports casting when used the resource is a back buffer. + + D3D11_FORMAT_SUPPORT_BACK_BUFFER_CAST + + + + Format can be used for an unordered access view. + + D3D11_FORMAT_SUPPORT_TYPED_UNORDERED_ACCESS_VIEW + + + + Format can be used with the HLSL gather with comparison function. + + D3D11_FORMAT_SUPPORT_SHADER_GATHER_COMPARISON + + + + Unordered resource support options for a compute shader resource (see ). + + D3D11_FORMAT_SUPPORT2 + + + + Format supports atomic add. + + D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_ADD + + + + Format supports atomic bitwise operations. + + D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_BITWISE_OPS + + + + Format supports atomic compare with store or exchange. + + D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE + + + + Format supports atomic exchange. + + D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_EXCHANGE + + + + Format supports atomic min and max. + + D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_SIGNED_MIN_OR_MAX + + + + Format supports atomic unsigned min and max. + + D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_UNSIGNED_MIN_OR_MAX + + + + Format supports a typed load. + + D3D11_FORMAT_SUPPORT2_UAV_TYPED_LOAD + + + + Format supports a typed store. + + D3D11_FORMAT_SUPPORT2_UAV_TYPED_STORE + + + + None. + + None + + + + Optional flags that control the behavior of {{ID3D11Asynchronous::GetData}}. + + D3D11_ASYNC_GETDATA_FLAG + + + + Do not flush the command buffer. This can potentially cause an infinite loop if GetData is continually called until it returns S_OK as there may still be commands in the command buffer that need to be processed in order for GetData to return S_OK. Since the commands in the command buffer are not flushed they will not be processed and therefore GetData will never return S_OK. + + D3D11_ASYNC_GETDATA_DONOTFLUSH + + + + None. + + None + + + + Query types. + + + Create a query with . + + D3D11_QUERY + + + + Determines whether or not the GPU is finished processing commands. When the GPU is finished processing commands will return S_OK, and pData will point to a BOOL with a value of TRUE. When using this type of query, is disabled. + + D3D11_QUERY_EVENT + + + + Get the number of samples that passed the depth and stencil tests in between and . returns a UINT64. If a depth or stencil test is disabled, then each of those tests will be counted as a pass. + + D3D11_QUERY_OCCLUSION + + + + Get a timestamp value where returns a UINT64. This kind of query is only useful if two timestamp queries are done in the middle of a D3D11_QUERY_TIMESTAMP_DISJOINT query. The difference of two timestamps can be used to determine how many ticks have elapsed, and the D3D11_QUERY_TIMESTAMP_DISJOINT query will determine if that difference is a reliable value and also has a value that shows how to convert the number of ticks into seconds. See . When using this type of query, is disabled. + + D3D11_QUERY_TIMESTAMP + + + + Determines whether or not a D3D11_QUERY_TIMESTAMP is returning reliable values, and also gives the frequency of the processor enabling you to convert the number of elapsed ticks into seconds. will return a . This type of query should only be invoked once per frame or less. + + D3D11_QUERY_TIMESTAMP_DISJOINT + + + + Get pipeline statistics, such as the number of pixel shader invocations in between and . will return a . + + D3D11_QUERY_PIPELINE_STATISTICS + + + + Similar to D3D11_QUERY_OCCLUSION, except returns a BOOL indicating whether or not any samples passed the depth and stencil tests - TRUE meaning at least one passed, FALSE meaning none passed. + + D3D11_QUERY_OCCLUSION_PREDICATE + + + + Get streaming output statistics, such as the number of primitives streamed out in between and . will return a structure. + + D3D11_QUERY_SO_STATISTICS + + + + Determines whether or not any of the streaming output buffers overflowed in between and . returns a BOOL - TRUE meaning there was an overflow, FALSE meaning there was not an overflow. If streaming output writes to multiple buffers, and one of the buffers overflows, then it will stop writing to all the output buffers. When an overflow is detected by Direct3D it is prevented from happening - no memory is corrupted. This predication may be used in conjunction with an SO_STATISTICS query so that when an overflow occurs the SO_STATISTIC query will let the application know how much memory was needed to prevent an overflow. + + D3D11_QUERY_SO_OVERFLOW_PREDICATE + + + + Get streaming output statistics for stream 0, such as the number of primitives streamed out in between and . will return a structure. + + D3D11_QUERY_SO_STATISTICS_STREAM0 + + + + Determines whether or not the stream 0 output buffers overflowed in between and . returns a BOOL - TRUE meaning there was an overflow, FALSE meaning there was not an overflow. If streaming output writes to multiple buffers, and one of the buffers overflows, then it will stop writing to all the output buffers. When an overflow is detected by Direct3D it is prevented from happening - no memory is corrupted. This predication may be used in conjunction with an SO_STATISTICS query so that when an overflow occurs the SO_STATISTIC query will let the application know how much memory was needed to prevent an overflow. + + D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM0 + + + + Get streaming output statistics for stream 1, such as the number of primitives streamed out in between and . will return a structure. + + D3D11_QUERY_SO_STATISTICS_STREAM1 + + + + Determines whether or not the stream 1 output buffers overflowed in between and . returns a BOOL - TRUE meaning there was an overflow, FALSE meaning there was not an overflow. If streaming output writes to multiple buffers, and one of the buffers overflows, then it will stop writing to all the output buffers. When an overflow is detected by Direct3D it is prevented from happening - no memory is corrupted. This predication may be used in conjunction with an SO_STATISTICS query so that when an overflow occurs the SO_STATISTIC query will let the application know how much memory was needed to prevent an overflow. + + D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM1 + + + + Get streaming output statistics for stream 2, such as the number of primitives streamed out in between and . will return a structure. + + D3D11_QUERY_SO_STATISTICS_STREAM2 + + + + Determines whether or not the stream 2 output buffers overflowed in between and . returns a BOOL - TRUE meaning there was an overflow, FALSE meaning there was not an overflow. If streaming output writes to multiple buffers, and one of the buffers overflows, then it will stop writing to all the output buffers. When an overflow is detected by Direct3D it is prevented from happening - no memory is corrupted. This predication may be used in conjunction with an SO_STATISTICS query so that when an overflow occurs the SO_STATISTIC query will let the application know how much memory was needed to prevent an overflow. + + D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM2 + + + + Get streaming output statistics for stream 3, such as the number of primitives streamed out in between and . will return a structure. + + D3D11_QUERY_SO_STATISTICS_STREAM3 + + + + Determines whether or not the stream 3 output buffers overflowed in between and . returns a BOOL - TRUE meaning there was an overflow, FALSE meaning there was not an overflow. If streaming output writes to multiple buffers, and one of the buffers overflows, then it will stop writing to all the output buffers. When an overflow is detected by Direct3D it is prevented from happening - no memory is corrupted. This predication may be used in conjunction with an SO_STATISTICS query so that when an overflow occurs the SO_STATISTIC query will let the application know how much memory was needed to prevent an overflow. + + D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM3 + + + + Flags that describe miscellaneous query behavior. + + + This flag is part of a query description (see ). + + D3D11_QUERY_MISC_FLAG + + + + Tell the hardware that if it is not yet sure if something is hidden or not to draw it anyway. This is only used with an occlusion predicate. Predication data cannot be returned to your application via when using this flag. + + D3D11_QUERY_MISC_PREDICATEHINT + + + + None. + + None + + + + Options for performance counters. + + + Independent hardware vendors may define their own set of performance counters for their devices, by giving the enumeration value a number that is greater than the value for D3D11_COUNTER_DEVICE_DEPENDENT_0. This enumeration is used by and . + + D3D11_COUNTER + + + + Define a performance counter that is dependent on the hardware device. + + D3D11_COUNTER_DEVICE_DEPENDENT_0 + + + + Data type of a performance counter. + + + These flags are an output parameter in . + + D3D11_COUNTER_TYPE + + + + 32-bit floating point. + + D3D11_COUNTER_TYPE_FLOAT32 + + + + 16-bit unsigned integer. + + D3D11_COUNTER_TYPE_UINT16 + + + + 32-bit unsigned integer. + + D3D11_COUNTER_TYPE_UINT32 + + + + 64-bit unsigned integer. + + D3D11_COUNTER_TYPE_UINT64 + + + + Specifies a multi-sample pattern type. + + D3D11_STANDARD_MULTISAMPLE_QUALITY_LEVELS + + + + Pre-defined multi-sample patterns required for DX11 and DX10.1 hardware. + + D3D11_STANDARD_MULTISAMPLE_PATTERN + + + + Pattern where all of the samples are located at the pixel center. + + D3D11_CENTER_MULTISAMPLE_PATTERN + + + + Device context options. + + + This enumeration is used by . + + D3D11_DEVICE_CONTEXT_TYPE + + + + The device context is an immediate context. + + D3D11_DEVICE_CONTEXT_IMMEDIATE + + + + The device context is a deferred context. + + D3D11_DEVICE_CONTEXT_DEFERRED + + + + Direct3D 11 feature options. + + + This enumeration is used when querying a driver about support for these features by calling . Each value in this enumeration has a corresponding data structure that is required to be passed to the pFeatureSupportData parameter of ID3D11Device::CheckFeatureSupport. The following table shows the structures associated with each enumerant. EnumerantAssociated Structure D3D11_FEATURE_THREADING D3D11_FEATURE_DOUBLES D3D11_FEATURE_FORMAT_SUPPORT D3D11_FEATURE_FORMAT_SUPPORT2 D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS ? + + D3D11_FEATURE + + + + The driver supports {{multithreading}}. To see an example of testing a driver for multithread support, see {{How To: Check for Driver Support}}. + + D3D11_FEATURE_THREADING + + + + Supports the use of the doubles type in HLSL. + + D3D11_FEATURE_DOUBLES + + + + Supports the formats in . + + D3D11_FEATURE_FORMAT_SUPPORT + + + + Supports the formats in . + + D3D11_FEATURE_FORMAT_SUPPORT2 + + + + Supports compute shaders and raw and structured buffers. + + D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS + + + + Describes parameters that are used to create a device. + + + Device creation flags are used by and . An application might dynamically create (and destroy) threads to improve performance especially on a machine with multiple CPU cores. There may be cases, however, when an application needs to prevent extra threads from being created. This can happen when you want to simplify debugging, profile code or develop a tool for instance. For these cases, use D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS to request that the runtime and video driver not create any additional threads that might interfere with the application. + + D3D11_CREATE_DEVICE_FLAG + + + + You should use this flag if your application will only call methods of Direct3D 11 interfaces from a single thread. By default, the object is {{thread-safe}}. By using this flag, you can increase performance. However, if you use this flag and your application calls methods of Direct3D 11 interfaces from multiple threads, undefined behavior might result. + + D3D11_CREATE_DEVICE_SINGLETHREADED + + + + Creates a device that supports the debug layer. + + D3D11_CREATE_DEVICE_DEBUG + + + + Note??This flag is not supported in Direct3D 11. + + D3D11_CREATE_DEVICE_SWITCH_TO_REF + + + + Prevents multiple threads from being created. When this flag is used with a WARP device, no additional threads will be created by WARP and all rasterization will occur on the calling thread. This flag is not recommended for general use. See remarks. + + D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS + + + + Required for Direct2D interoperability with Direct3D resources. + + D3D11_CREATE_DEVICE_BGRA_SUPPORT + + + + None. + + None + + + + Options for the amount of information to report about a device object's lifetime. + + + This enumeration is used by . Several inline functions exist to combine the options using operators, see the D3D11SDKLayers.h header file for details. + + D3D11_RLDO_FLAGS + + + + Specifies to obtain a summary about a device object's lifetime. + + D3D11_RLDO_SUMMARY + + + + Specifies to obtain detailed information about a device object's lifetime. + + D3D11_RLDO_DETAIL + + + + None. + + None + + + + Categories of debug messages. This will identify the category of a message when retrieving a message with and when adding a message with . When creating an {{info queue filter}}, these values can be used to allow or deny any categories of messages to pass through the storage and retrieval filters. + + + This is part of the Information Queue feature. See . + + D3D11_MESSAGE_CATEGORY + + + + User defined message. See . + + D3D11_MESSAGE_CATEGORY_APPLICATION_DEFINED + + + + No documentation. + + D3D11_MESSAGE_CATEGORY_MISCELLANEOUS + + + + No documentation. + + D3D11_MESSAGE_CATEGORY_INITIALIZATION + + + + No documentation. + + D3D11_MESSAGE_CATEGORY_CLEANUP + + + + No documentation. + + D3D11_MESSAGE_CATEGORY_COMPILATION + + + + No documentation. + + D3D11_MESSAGE_CATEGORY_STATE_CREATION + + + + No documentation. + + D3D11_MESSAGE_CATEGORY_STATE_SETTING + + + + No documentation. + + D3D11_MESSAGE_CATEGORY_STATE_GETTING + + + + No documentation. + + D3D11_MESSAGE_CATEGORY_RESOURCE_MANIPULATION + + + + No documentation. + + D3D11_MESSAGE_CATEGORY_EXECUTION + + + + Debug message severity levels for an information queue. + + + Use these values to allow or deny message categories to pass through the storage and retrieval filters for an information queue (see ). This API is used by . + + D3D11_MESSAGE_SEVERITY + + + + Defines some type of corruption which has occurred. + + D3D11_MESSAGE_SEVERITY_CORRUPTION + + + + Defines an error message. + + D3D11_MESSAGE_SEVERITY_ERROR + + + + Defines a warning message. + + D3D11_MESSAGE_SEVERITY_WARNING + + + + Defines an information message. + + D3D11_MESSAGE_SEVERITY_INFO + + + + Debug messages for setting up an info-queue filter (see ); use these messages to allow or deny message categories to pass through the storage and retrieval filters. These IDs are used by methods such as or . + + D3D11_MESSAGE_ID + + + + No documentation. + + D3D11_MESSAGE_ID_UNKNOWN + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_VSSETSHADERRESOURCES_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_VSSETCONSTANTBUFFERS_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_GSSETSHADERRESOURCES_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_GSSETCONSTANTBUFFERS_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_PSSETSHADERRESOURCES_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_PSSETCONSTANTBUFFERS_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETS_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SOSETTARGETS_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_STRING_FROM_APPLICATION + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_THIS + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER1 + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER2 + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER3 + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER4 + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER5 + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER6 + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER7 + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER8 + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER9 + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER10 + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER11 + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER12 + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER13 + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER14 + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER15 + + + + No documentation. + + D3D11_MESSAGE_ID_CORRUPTED_MULTITHREADING + + + + No documentation. + + D3D11_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY + + + + No documentation. + + D3D11_MESSAGE_ID_IASETINPUTLAYOUT_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_IASETVERTEXBUFFERS_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_IASETINDEXBUFFER_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_VSSETSHADER_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_VSSETSHADERRESOURCES_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_VSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_VSSETSAMPLERS_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_GSSETSHADER_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_GSSETSHADERRESOURCES_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_GSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_GSSETSAMPLERS_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_SOSETTARGETS_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_PSSETSHADER_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_PSSETSHADERRESOURCES_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_PSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_PSSETSAMPLERS_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_RSSETSTATE_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_OMSETBLENDSTATE_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_OMSETDEPTHSTENCILSTATE_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_OMSETRENDERTARGETS_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_SETPREDICATION_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_GETPRIVATEDATA_MOREDATA + + + + No documentation. + + D3D11_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA + + + + No documentation. + + D3D11_MESSAGE_ID_SETPRIVATEDATA_INVALIDIUNKNOWN + + + + No documentation. + + D3D11_MESSAGE_ID_SETPRIVATEDATA_INVALIDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS + + + + No documentation. + + D3D11_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDSAMPLES + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDUSAGE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDBINDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDCPUACCESSFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDMISCFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDCPUACCESSFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDBINDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDINITIALDATA + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDDIMENSIONS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDMIPLEVELS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDMISCFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDARG_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_OUTOFMEMORY_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_NULLDESC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDCONSTANTBUFFERBINDINGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_LARGEALLOCATION + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_UNSUPPORTEDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDSAMPLES + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDUSAGE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDBINDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDCPUACCESSFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDMISCFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDCPUACCESSFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDBINDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDINITIALDATA + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDDIMENSIONS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDMIPLEVELS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDMISCFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDARG_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_OUTOFMEMORY_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_NULLDESC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE1D_LARGEALLOCATION + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_UNSUPPORTEDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDSAMPLES + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDUSAGE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDBINDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDCPUACCESSFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDMISCFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDCPUACCESSFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDBINDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDINITIALDATA + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDDIMENSIONS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDMIPLEVELS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDMISCFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDARG_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_OUTOFMEMORY_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_NULLDESC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE2D_LARGEALLOCATION + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_UNSUPPORTEDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDSAMPLES + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDUSAGE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDBINDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDCPUACCESSFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDMISCFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDCPUACCESSFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDBINDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDINITIALDATA + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDDIMENSIONS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDMIPLEVELS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDMISCFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDARG_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_OUTOFMEMORY_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_NULLDESC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATETEXTURE3D_LARGEALLOCATION + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_TOOMANYOBJECTS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARG_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_OUTOFMEMORY_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_TOOMANYOBJECTS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARG_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_OUTOFMEMORY_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_TOOMANYOBJECTS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDARG_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_OUTOFMEMORY_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_NULLDESC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDDECL + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_EXPECTEDDECL + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_TOOMANYOBJECTS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_NULLDESC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_TOOMANYOBJECTS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_NULLDESC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBLENDSTATE_TOOMANYOBJECTS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBLENDSTATE_NULLDESC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDFILTER + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSU + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSV + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSW + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMIPLODBIAS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXANISOTROPY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDCOMPARISONFUNC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMINLOD + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXLOD + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_TOOMANYOBJECTS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_NULLDESC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_INVALIDQUERY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_INVALIDMISCFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_UNEXPECTEDMISCFLAG + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_NULLDESC + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNRECOGNIZED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNDEFINED + + + + No documentation. + + D3D11_MESSAGE_ID_IASETVERTEXBUFFERS_INVALIDBUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_OFFSET_TOO_LARGE + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_BUFFERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_IASETINDEXBUFFER_INVALIDBUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_FORMAT_INVALID + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_OFFSET_TOO_LARGE + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_OFFSET_UNALIGNED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_VSSETSHADERRESOURCES_VIEWS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_VSSETCONSTANTBUFFERS_INVALIDBUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_VSSETCONSTANTBUFFERS_BUFFERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_VSSETSAMPLERS_SAMPLERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_GSSETSHADERRESOURCES_VIEWS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_GSSETCONSTANTBUFFERS_INVALIDBUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_GSSETCONSTANTBUFFERS_BUFFERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_GSSETSAMPLERS_SAMPLERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_SOSETTARGETS_INVALIDBUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SOSETTARGETS_OFFSET_UNALIGNED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_PSSETSHADERRESOURCES_VIEWS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_PSSETCONSTANTBUFFERS_INVALIDBUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_PSSETCONSTANTBUFFERS_BUFFERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_PSSETSAMPLERS_SAMPLERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_INVALIDVIEWPORT + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_INVALIDSCISSOR + + + + No documentation. + + D3D11_MESSAGE_ID_CLEARRENDERTARGETVIEW_DENORMFLUSH + + + + No documentation. + + D3D11_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DENORMFLUSH + + + + No documentation. + + D3D11_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_IAGETVERTEXBUFFERS_BUFFERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_VSGETSHADERRESOURCES_VIEWS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_VSGETCONSTANTBUFFERS_BUFFERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_VSGETSAMPLERS_SAMPLERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_GSGETSHADERRESOURCES_VIEWS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_GSGETCONSTANTBUFFERS_BUFFERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_GSGETSAMPLERS_SAMPLERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SOGETTARGETS_BUFFERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_PSGETSHADERRESOURCES_VIEWS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_PSGETCONSTANTBUFFERS_BUFFERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_PSGETSAMPLERS_SAMPLERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_RSGETVIEWPORTS_VIEWPORTS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_RSGETSCISSORRECTS_RECTS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_GENERATEMIPS_RESOURCE_INVALID + + + + No documentation. + + D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDDESTINATIONSUBRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCESUBRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCEBOX + + + + No documentation. + + D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDDESTINATIONSTATE + + + + No documentation. + + D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCESTATE + + + + No documentation. + + D3D11_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_COPYRESOURCE_INVALIDDESTINATIONSTATE + + + + No documentation. + + D3D11_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCESTATE + + + + No documentation. + + D3D11_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSUBRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONBOX + + + + No documentation. + + D3D11_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSTATE + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_INVALID + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_SUBRESOURCE_INVALID + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_INVALID + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_SUBRESOURCE_INVALID + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_FORMAT_INVALID + + + + No documentation. + + D3D11_MESSAGE_ID_BUFFER_MAP_INVALIDMAPTYPE + + + + No documentation. + + D3D11_MESSAGE_ID_BUFFER_MAP_INVALIDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_BUFFER_MAP_ALREADYMAPPED + + + + No documentation. + + D3D11_MESSAGE_ID_BUFFER_MAP_DEVICEREMOVED_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_BUFFER_UNMAP_NOTMAPPED + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE1D_MAP_INVALIDMAPTYPE + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE1D_MAP_INVALIDSUBRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE1D_MAP_INVALIDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE1D_MAP_ALREADYMAPPED + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE1D_MAP_DEVICEREMOVED_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE1D_UNMAP_INVALIDSUBRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE1D_UNMAP_NOTMAPPED + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE2D_MAP_INVALIDMAPTYPE + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE2D_MAP_INVALIDSUBRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE2D_MAP_INVALIDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE2D_MAP_ALREADYMAPPED + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE2D_MAP_DEVICEREMOVED_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE2D_UNMAP_INVALIDSUBRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE2D_UNMAP_NOTMAPPED + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE3D_MAP_INVALIDMAPTYPE + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE3D_MAP_INVALIDSUBRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE3D_MAP_INVALIDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE3D_MAP_ALREADYMAPPED + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE3D_MAP_DEVICEREMOVED_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE3D_UNMAP_INVALIDSUBRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_TEXTURE3D_UNMAP_NOTMAPPED + + + + No documentation. + + D3D11_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_DEPRECATED + + + + No documentation. + + D3D11_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_FORMAT_DEPRECATED + + + + No documentation. + + D3D11_MESSAGE_ID_SETEXCEPTIONMODE_UNRECOGNIZEDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_SETEXCEPTIONMODE_INVALIDARG_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_SETEXCEPTIONMODE_DEVICEREMOVED_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_REF_SIMULATING_INFINITELY_FAST_HARDWARE + + + + No documentation. + + D3D11_MESSAGE_ID_REF_THREADING_MODE + + + + No documentation. + + D3D11_MESSAGE_ID_REF_UMDRIVER_EXCEPTION + + + + No documentation. + + D3D11_MESSAGE_ID_REF_KMDRIVER_EXCEPTION + + + + No documentation. + + D3D11_MESSAGE_ID_REF_HARDWARE_EXCEPTION + + + + No documentation. + + D3D11_MESSAGE_ID_REF_ACCESSING_INDEXABLE_TEMP_OUT_OF_RANGE + + + + No documentation. + + D3D11_MESSAGE_ID_REF_PROBLEM_PARSING_SHADER + + + + No documentation. + + D3D11_MESSAGE_ID_REF_OUT_OF_MEMORY + + + + No documentation. + + D3D11_MESSAGE_ID_REF_INFO + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEXPOS_OVERFLOW + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAWINDEXED_INDEXPOS_OVERFLOW + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAWINSTANCED_VERTEXPOS_OVERFLOW + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAWINSTANCED_INSTANCEPOS_OVERFLOW + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INSTANCEPOS_OVERFLOW + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INDEXPOS_OVERFLOW + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_SHADER_NOT_SET + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERINDEX + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_COMPONENTTYPE + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERMASK + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SYSTEMVALUE + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_NOT_SET + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_INPUTLAYOUT_NOT_SET + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_CONSTANT_BUFFER_NOT_SET + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_CONSTANT_BUFFER_TOO_SMALL + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_SAMPLER_NOT_SET + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_SHADERRESOURCEVIEW_NOT_SET + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_VIEW_DIMENSION_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_TOO_SMALL + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_NOT_SET + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_FORMAT_INVALID + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_TOO_SMALL + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_GS_INPUT_PRIMITIVE_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_RETURN_TYPE_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_POSITION_NOT_PRESENT + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_OUTPUT_STREAM_NOT_SET + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_BOUND_RESOURCE_MAPPED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_INVALID_PRIMITIVETOPOLOGY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_OFFSET_UNALIGNED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_STRIDE_UNALIGNED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_INDEX_OFFSET_UNALIGNED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_OUTPUT_STREAM_OFFSET_UNALIGNED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_LD_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_SAMPLE_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_SAMPLE_C_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_MULTISAMPLE_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_SO_TARGETS_BOUND_WITHOUT_SOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_SO_STRIDE_LARGER_THAN_BUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_INVALIDARG_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_OUTOFMEMORY_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BADINTERFACE_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_VIEWPORT_NOT_SET + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_DENORMFLUSH + + + + No documentation. + + D3D11_MESSAGE_ID_OMSETRENDERTARGETS_INVALIDVIEW + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SETTEXTFILTERSIZE_INVALIDDIMENSIONS + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_SAMPLER_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_BLENDSTATE_GETDESC_LEGACY + + + + No documentation. + + D3D11_MESSAGE_ID_SHADERRESOURCEVIEW_GETDESC_LEGACY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEQUERY_OUTOFMEMORY_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEPREDICATE_OUTOFMEMORY_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATECOUNTER_OUTOFRANGE_COUNTER + + + + No documentation. + + D3D11_MESSAGE_ID_CREATECOUNTER_SIMULTANEOUS_ACTIVE_COUNTERS_EXHAUSTED + + + + No documentation. + + D3D11_MESSAGE_ID_CREATECOUNTER_UNSUPPORTED_WELLKNOWN_COUNTER + + + + No documentation. + + D3D11_MESSAGE_ID_CREATECOUNTER_OUTOFMEMORY_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATECOUNTER_NONEXCLUSIVE_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATECOUNTER_NULLDESC + + + + No documentation. + + D3D11_MESSAGE_ID_CHECKCOUNTER_OUTOFRANGE_COUNTER + + + + No documentation. + + D3D11_MESSAGE_ID_CHECKCOUNTER_UNSUPPORTED_WELLKNOWN_COUNTER + + + + No documentation. + + D3D11_MESSAGE_ID_SETPREDICATION_INVALID_PREDICATE_STATE + + + + No documentation. + + D3D11_MESSAGE_ID_QUERY_BEGIN_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_PREDICATE_BEGIN_DURING_PREDICATION + + + + No documentation. + + D3D11_MESSAGE_ID_QUERY_BEGIN_DUPLICATE + + + + No documentation. + + D3D11_MESSAGE_ID_QUERY_BEGIN_ABANDONING_PREVIOUS_RESULTS + + + + No documentation. + + D3D11_MESSAGE_ID_PREDICATE_END_DURING_PREDICATION + + + + No documentation. + + D3D11_MESSAGE_ID_QUERY_END_ABANDONING_PREVIOUS_RESULTS + + + + No documentation. + + D3D11_MESSAGE_ID_QUERY_END_WITHOUT_BEGIN + + + + No documentation. + + D3D11_MESSAGE_ID_QUERY_GETDATA_INVALID_DATASIZE + + + + No documentation. + + D3D11_MESSAGE_ID_QUERY_GETDATA_INVALID_FLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_QUERY_GETDATA_INVALID_CALL + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_PS_OUTPUT_TYPE_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_GATHER_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_STRIDE_TOO_LARGE + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_INVALIDRANGE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_SAMPLE_COUNT_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_D3D10_MESSAGES_END + + + + No documentation. + + D3D11_MESSAGE_ID_D3D10L9_MESSAGES_START + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_STENCIL_NO_TWO_SIDED + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_DepthBiasClamp_NOT_SUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_NO_COMPARISON_SUPPORT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_EXCESSIVE_ANISOTROPY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_BORDER_OUT_OF_RANGE + + + + No documentation. + + D3D11_MESSAGE_ID_VSSETSAMPLERS_NOT_SUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_VSSETSAMPLERS_TOO_MANY_SAMPLERS + + + + No documentation. + + D3D11_MESSAGE_ID_PSSETSAMPLERS_TOO_MANY_SAMPLERS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_NO_ARRAYS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_NO_VB_AND_IB_BIND + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_NO_TEXTURE_1D + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_DIMENSION_OUT_OF_RANGE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_NOT_BINDABLE_AS_SHADER_RESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_OMSETRENDERTARGETS_TOO_MANY_RENDER_TARGETS + + + + No documentation. + + D3D11_MESSAGE_ID_OMSETRENDERTARGETS_NO_DIFFERING_BIT_DEPTHS + + + + No documentation. + + D3D11_MESSAGE_ID_IASETVERTEXBUFFERS_BAD_BUFFER_INDEX + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_TOO_MANY_VIEWPORTS + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_ADJACENCY_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_TOO_MANY_SCISSORS + + + + No documentation. + + D3D11_MESSAGE_ID_COPYRESOURCE_ONLY_TEXTURE_2D_WITHIN_GPU_MEMORY + + + + No documentation. + + D3D11_MESSAGE_ID_COPYRESOURCE_NO_TEXTURE_3D_READBACK + + + + No documentation. + + D3D11_MESSAGE_ID_COPYRESOURCE_NO_TEXTURE_ONLY_READBACK + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_UNSUPPORTED_FORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBLENDSTATE_NO_ALPHA_TO_COVERAGE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_DepthClipEnable_MUST_BE_TRUE + + + + No documentation. + + D3D11_MESSAGE_ID_DRAWINDEXED_STARTINDEXLOCATION_MUST_BE_POSITIVE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_MUST_USE_LOWEST_LOD + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_MINLOD_MUST_NOT_BE_FRACTIONAL + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_MAXLOD_MUST_BE_FLT_MAX + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_FIRSTARRAYSLICE_MUST_BE_ZERO + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_CUBES_MUST_HAVE_6_SIDES + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_NOT_BINDABLE_AS_RENDER_TARGET + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_NO_DWORD_INDEX_BUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_MSAA_PRECLUDES_SHADER_RESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_PRESENTATION_PRECLUDES_SHADER_RESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBLENDSTATE_NO_INDEPENDENT_BLEND_ENABLE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBLENDSTATE_NO_INDEPENDENT_WRITE_MASKS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_NO_STREAM_OUT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_ONLY_VB_IB_FOR_BUFFERS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_NO_AUTOGEN_FOR_VOLUMES + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_DXGI_FORMAT_R8G8B8A8_CANNOT_BE_SHARED + + + + No documentation. + + D3D11_MESSAGE_ID_VSSHADERRESOURCES_NOT_SUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_GEOMETRY_SHADER_NOT_SUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_STREAM_OUT_NOT_SUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_TEXT_FILTER_NOT_SUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBLENDSTATE_NO_SEPARATE_ALPHA_BLEND + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBLENDSTATE_NO_MRT_BLEND + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBLENDSTATE_OPERATION_NOT_SUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_NO_MIRRORONCE + + + + No documentation. + + D3D11_MESSAGE_ID_DRAWINSTANCED_NOT_SUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DRAWINDEXEDINSTANCED_NOT_SUPPORTED_BELOW_9_3 + + + + No documentation. + + D3D11_MESSAGE_ID_DRAWINDEXED_POINTLIST_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_SETBLENDSTATE_SAMPLE_MASK_CANNOT_BE_ZERO + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_DIMENSION_EXCEEDS_FEATURE_LEVEL_DEFINITION + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_ONLY_SINGLE_MIP_LEVEL_DEPTH_STENCIL_SUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_NEGATIVESCISSOR + + + + No documentation. + + D3D11_MESSAGE_ID_SLOT_ZERO_MUST_BE_D3D10_INPUT_PER_VERTEX_DATA + + + + No documentation. + + D3D11_MESSAGE_ID_CREATERESOURCE_NON_POW_2_MIPMAP + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_BORDER_NOT_SUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_OMSETRENDERTARGETS_NO_SRGB_MRT + + + + No documentation. + + D3D11_MESSAGE_ID_D3D10L9_MESSAGES_END + + + + No documentation. + + D3D11_MESSAGE_ID_D3D11_MESSAGES_START + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDCLASSLINKAGE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTREAMS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTREAMS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCLASSLINKAGE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEPIXELSHADER_INVALIDCLASSLINKAGE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEFERREDCONTEXT_INVALID_COMMANDLISTFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEFERREDCONTEXT_SINGLETHREADED + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEFERREDCONTEXT_INVALIDARG_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEFERREDCONTEXT_INVALID_CALL_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDEFERREDCONTEXT_OUTOFMEMORY_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_FINISHDISPLAYLIST_ONIMMEDIATECONTEXT + + + + No documentation. + + D3D11_MESSAGE_ID_FINISHDISPLAYLIST_OUTOFMEMORY_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_FINISHDISPLAYLIST_INVALID_CALL_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_HSSETSHADERRESOURCES_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_HSSETCONSTANTBUFFERS_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_HSSETSHADERRESOURCES_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_HSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEHULLSHADER_INVALIDCALL + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEHULLSHADER_OUTOFMEMORY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERBYTECODE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERTYPE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEHULLSHADER_INVALIDCLASSLINKAGE + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_HSSETSHADERRESOURCES_VIEWS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_HSSETCONSTANTBUFFERS_INVALIDBUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_HSSETCONSTANTBUFFERS_BUFFERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_HSSETSAMPLERS_SAMPLERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_HSGETSHADERRESOURCES_VIEWS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_HSGETCONSTANTBUFFERS_BUFFERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_HSGETSAMPLERS_SAMPLERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DSSETSHADERRESOURCES_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DSSETCONSTANTBUFFERS_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_DSSETSHADERRESOURCES_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_DSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCALL + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDOMAINSHADER_OUTOFMEMORY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERBYTECODE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERTYPE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCLASSLINKAGE + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DSSETSHADERRESOURCES_VIEWS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DSSETCONSTANTBUFFERS_INVALIDBUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DSSETCONSTANTBUFFERS_BUFFERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DSSETSAMPLERS_SAMPLERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DSGETSHADERRESOURCES_VIEWS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DSGETCONSTANTBUFFERS_BUFFERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DSGETSAMPLERS_SAMPLERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_HS_XOR_DS_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_DEFERRED_CONTEXT_REMOVAL_PROCESS_AT_FAULT + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAWINDIRECT_INVALID_ARG_BUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_UNALIGNED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_OVERFLOW + + + + No documentation. + + D3D11_MESSAGE_ID_RESOURCE_MAP_INVALIDMAPTYPE + + + + No documentation. + + D3D11_MESSAGE_ID_RESOURCE_MAP_INVALIDSUBRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_RESOURCE_MAP_INVALIDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_RESOURCE_MAP_ALREADYMAPPED + + + + No documentation. + + D3D11_MESSAGE_ID_RESOURCE_MAP_DEVICEREMOVED_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_RESOURCE_MAP_OUTOFMEMORY_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_RESOURCE_MAP_WITHOUT_INITIAL_DISCARD + + + + No documentation. + + D3D11_MESSAGE_ID_RESOURCE_UNMAP_INVALIDSUBRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_RESOURCE_UNMAP_NOTMAPPED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_RASTERIZING_CONTROL_POINTS + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_HS_DS_SIGNATURE_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_HS_DS_CONTROL_POINT_COUNT_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_HS_DS_TESSELLATOR_DOMAIN_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_CONTEXT + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_CONTEXT + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_CONTEXT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_BUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_BUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_BUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_TEXTURE1D + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_TEXTURE1D + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_TEXTURE1D + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_TEXTURE2D + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_TEXTURE2D + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_TEXTURE2D + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_TEXTURE3D + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_TEXTURE3D + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_TEXTURE3D + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_SHADERRESOURCEVIEW + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_SHADERRESOURCEVIEW + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_SHADERRESOURCEVIEW + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_RENDERTARGETVIEW + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_RENDERTARGETVIEW + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_RENDERTARGETVIEW + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_DEPTHSTENCILVIEW + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_DEPTHSTENCILVIEW + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_DEPTHSTENCILVIEW + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_VERTEXSHADER + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_VERTEXSHADER + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_VERTEXSHADER + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_HULLSHADER + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_HULLSHADER + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_HULLSHADER + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_DOMAINSHADER + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_DOMAINSHADER + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_DOMAINSHADER + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_GEOMETRYSHADER + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_GEOMETRYSHADER + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_GEOMETRYSHADER + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_PIXELSHADER + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_PIXELSHADER + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_PIXELSHADER + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_INPUTLAYOUT + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_INPUTLAYOUT + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_INPUTLAYOUT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_SAMPLER + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_SAMPLER + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_SAMPLER + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_BLENDSTATE + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_BLENDSTATE + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_BLENDSTATE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_DEPTHSTENCILSTATE + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_DEPTHSTENCILSTATE + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_DEPTHSTENCILSTATE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_RASTERIZERSTATE + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_RASTERIZERSTATE + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_RASTERIZERSTATE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_QUERY + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_QUERY + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_QUERY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_PREDICATE + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_PREDICATE + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_PREDICATE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_COUNTER + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_COUNTER + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_COUNTER + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_COMMANDLIST + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_COMMANDLIST + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_COMMANDLIST + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_CLASSINSTANCE + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_CLASSINSTANCE + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_CLASSINSTANCE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_CLASSLINKAGE + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_CLASSLINKAGE + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_CLASSLINKAGE + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_DEVICE + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_OBJECT_SUMMARY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_COMPUTESHADER + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_COMPUTESHADER + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_COMPUTESHADER + + + + No documentation. + + D3D11_MESSAGE_ID_CREATE_UNORDEREDACCESSVIEW + + + + No documentation. + + D3D11_MESSAGE_ID_LIVE_UNORDEREDACCESSVIEW + + + + No documentation. + + D3D11_MESSAGE_ID_DESTROY_UNORDEREDACCESSVIEW + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SETSHADER_INTERFACES_FEATURELEVEL + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SETSHADER_INTERFACE_COUNT_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SETSHADER_INVALID_INSTANCE + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SETSHADER_INVALID_INSTANCE_INDEX + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SETSHADER_INVALID_INSTANCE_TYPE + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SETSHADER_INVALID_INSTANCE_DATA + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SETSHADER_UNBOUND_INSTANCE_DATA + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SETSHADER_INSTANCE_DATA_BINDINGS + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CREATESHADER_CLASSLINKAGE_FULL + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_UNRECOGNIZED_FEATURE + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_INVALIDARG_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CSSETSHADERRESOURCES_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CSSETCONSTANTBUFFERS_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_CSSETSHADERRESOURCES_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_CSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCALL + + + + No documentation. + + D3D11_MESSAGE_ID_CREATECOMPUTESHADER_OUTOFMEMORY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERBYTECODE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERTYPE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCLASSLINKAGE + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CSSETSHADERRESOURCES_VIEWS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_CSSETCONSTANTBUFFERS_INVALIDBUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CSSETCONSTANTBUFFERS_BUFFERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CSSETSAMPLERS_SAMPLERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CSGETSHADERRESOURCES_VIEWS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CSGETCONSTANTBUFFERS_BUFFERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CSGETSAMPLERS_SAMPLERS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDSTRUCTURESTRIDE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDESC + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_OVERLAPPING_OLD_SLOTS + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_NO_OP + + + + No documentation. + + D3D11_MESSAGE_ID_CSSETUNORDEREDACCESSVIEWS_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_PSSETUNORDEREDACCESSVIEWS_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDARG_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_OUTOFMEMORY_RETURN + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_TOOMANYOBJECTS + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSVIEWS_HAZARD + + + + No documentation. + + D3D11_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_DENORMFLUSH + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSS_VIEWS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CSGETUNORDEREDACCESSS_VIEWS_EMPTY + + + + No documentation. + + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS + + + + No documentation. + + D3D11_MESSAGE_ID_CREATESHADERRESESOURCEVIEW_TOOMANYOBJECTS + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_INVALID_ARG_BUFFER + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_UNALIGNED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_OVERFLOW + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SETRESOURCEMINLOD_INVALIDCONTEXT + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SETRESOURCEMINLOD_INVALIDRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SETRESOURCEMINLOD_INVALIDMINLOD + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_GETRESOURCEMINLOD_INVALIDCONTEXT + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_GETRESOURCEMINLOD_INVALIDRESOURCE + + + + No documentation. + + D3D11_MESSAGE_ID_OMSETDEPTHSTENCIL_UNBINDDELETINGOBJECT + + + + No documentation. + + D3D11_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DEPTH_READONLY + + + + No documentation. + + D3D11_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_STENCIL_READONLY + + + + No documentation. + + D3D11_MESSAGE_ID_CHECKFEATURESUPPORT_FORMAT_DEPRECATED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RETURN_TYPE_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DRAW_UNORDEREDACCESSVIEW_RENDERTARGETVIEW_OVERLAP + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_DIMENSION_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_APPEND_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMICS_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_STRUCTURE_STRIDE_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_BUFFER_TYPE_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RAW_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_LD_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_STORE_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_ADD_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_BITWISE_OPS_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_CMPSTORE_CMPEXCHANGE_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_EXCHANGE_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_SIGNED_MINMAX_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_UNSIGNED_MINMAX_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DISPATCH_BOUND_RESOURCE_MAPPED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_OVERFLOW + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_ZERO + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_STRUCTURE_STRIDE_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_BUFFER_TYPE_MISMATCH + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_RAW_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DISPATCH_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDOFFSET + + + + No documentation. + + D3D11_MESSAGE_ID_COPYSTRUCTURECOUNT_LARGEOFFSET + + + + No documentation. + + D3D11_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDDESTINATIONSTATE + + + + No documentation. + + D3D11_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDSOURCESTATE + + + + No documentation. + + D3D11_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_NOT_SUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSVIEWS_INVALIDVIEW + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSVIEWS_INVALIDOFFSET + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSVIEWS_TOOMANYVIEWS + + + + No documentation. + + D3D11_MESSAGE_ID_CLEARUNORDEREDACCESSVIEWFLOAT_INVALIDFORMAT + + + + No documentation. + + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_COUNTER_UNSUPPORTED + + + + No documentation. + + D3D11_MESSAGE_ID_REF_WARNING + + + + No documentation. + + D3D11_MESSAGE_ID_D3D11_MESSAGES_END + + + + No documentation. + + D3D11_DEBUG_FEATURE_FLAGS + + + + No documentation. + + D3D11_DEBUG_FEATURE_FLUSH_PER_RENDER_OP + + + + No documentation. + + D3D11_DEBUG_FEATURE_FINISH_PER_RENDER_OP + + + + No documentation. + + D3D11_DEBUG_FEATURE_PRESENT_PER_RENDER_OP + + + + Texture filtering flags. + + + D3DX11 automatically performs gamma correction (to convert color data from RGB space to standard RGB space) when loading texture data. This is automatically done for instance when RGB data is loaded from a .png file into an sRGB texture. Use the SRGB filter flags to indicate if the data does not need to be converted into sRGB space. + + D3DX11_FILTER_FLAG + + + + No scaling or filtering will take place. Pixels outside the bounds of the source image are assumed to be transparent black. + + D3DX11_FILTER_NONE + + + + Each destination pixel is computed by sampling the nearest pixel from the source image. + + D3DX11_FILTER_POINT + + + + Each destination pixel is computed by sampling the four nearest pixels from the source image. This filter works best when the scale on both axes is less than two. + + D3DX11_FILTER_LINEAR + + + + Every pixel in the source image contributes equally to the destination image. This is the slowest of the filters. + + D3DX11_FILTER_TRIANGLE + + + + Each pixel is computed by averaging a 2x2(x2) box of pixels from the source image. This filter works only when the dimensions of the destination are half those of the source, as is the case with mipmaps. + + D3DX11_FILTER_BOX + + + + Pixels off the edge of the texture on the u-axis should be mirrored, not wrapped. + + D3DX11_FILTER_MIRROR_U + + + + Pixels off the edge of the texture on the v-axis should be mirrored, not wrapped. + + D3DX11_FILTER_MIRROR_V + + + + Pixels off the edge of the texture on the w-axis should be mirrored, not wrapped. + + D3DX11_FILTER_MIRROR_W + + + + Specifying this flag is the same as specifying the D3DX_FILTER_MIRROR_U, D3DX_FILTER_MIRROR_V, and D3DX_FILTER_MIRROR_W flags. + + D3DX11_FILTER_MIRROR + + + + The resulting image must be dithered using a 4x4 ordered dither algorithm. This happens when converting from one format to another. + + D3DX11_FILTER_DITHER + + + + Do diffuse dithering on the image when changing from one format to another. + + D3DX11_FILTER_DITHER_DIFFUSION + + + + Input data is in standard RGB (sRGB) color space. See remarks. + + D3DX11_FILTER_SRGB_IN + + + + Output data is in standard RGB (sRGB) color space. See remarks. + + D3DX11_FILTER_SRGB_OUT + + + + Same as specifying D3DX_FILTER_SRGB_IN | D3DX_FILTER_SRGB_OUT. See remarks. + + D3DX11_FILTER_SRGB + + + + Normal map options. Any number of these flags may be OR'd together in any combination. + + + These flags are used by . + + D3DX11_NORMALMAP_FLAG + + + + Indicates that pixels off the edge of the texture on the U-axis should be mirrored, not wraped. + + D3DX11_NORMALMAP_MIRROR_U + + + + Indicates that pixels off the edge of the texture on the V-axis should be mirrored, not wraped. + + D3DX11_NORMALMAP_MIRROR_V + + + + Same as D3DX11_NORMALMAP_MIRROR_U | D3DX11_NORMALMAP_MIRROR_V. + + D3DX11_NORMALMAP_MIRROR + + + + Inverts the direction of each normal. + + D3DX11_NORMALMAP_INVERTSIGN + + + + Computes the per pixel occlusion term and encodes it into the alpha. An Alpha of 1 means that the pixel is not obscured in any way, and an alpha of 0 would mean that the pixel is completly obscured. + + D3DX11_NORMALMAP_COMPUTE_OCCLUSION + + + + None. + + None + + + + These flags are used by functions which operate on one or more channels in a texture. + + D3DX11_CHANNEL_FLAG + + + + Indicates the red channel should be used. + + D3DX11_CHANNEL_RED + + + + Indicates the blue channel should be used. + + D3DX11_CHANNEL_BLUE + + + + Indicates the green channel should be used. + + D3DX11_CHANNEL_GREEN + + + + Indicates the alpha channel should be used. + + D3DX11_CHANNEL_ALPHA + + + + Indicates the luminaces of the red, green, and blue channels should be used. + + D3DX11_CHANNEL_LUMINANCE + + + + None. + + None + + + + Image file formats supported by D3DX11Createxxx and D3DX11Savexxx functions. + + + See {{Types of Bitmaps (GDI+)}} for more information on some of these formats. + + D3DX11_IMAGE_FILE_FORMAT + + + + Windows bitmap (BMP) file format. Contains a header that describes the resolution of the device on which the rectangle of pixels was created, the dimensions of the rectangle, the size of the array of bits, a logical palette, and an array of bits that defines the relationship between pixels in the bitmapped image and entries in the logical palette. + + D3DX11_IFF_BMP + + + + Joint Photographic Experts Group (JPEG) compressed file format. Specifies variable compression of 24-bit RGB color and 8-bit gray-scale Tagged Image File Format (TIFF) image document files. + + D3DX11_IFF_JPG + + + + Portable Network Graphics (PNG) file format. A non-proprietary bitmap format using lossless compression. + + D3DX11_IFF_PNG + + + + DirectDraw surface (DDS) file format. Stores textures, volume textures, and cubic environment maps, with or without mipmap levels, and with or without pixel compression. + + D3DX11_IFF_DDS + + + + Tagged Image File Format (TIFF). + + D3DX11_IFF_TIFF + + + + Graphics Interchange Format (GIF). + + D3DX11_IFF_GIF + + + + Windows Media Player format (WMP). + + D3DX11_IFF_WMP + + + + Type for scan data. + + D3DX11_SCAN_DATA_TYPE + + + + FLOAT data. + + D3DX11_SCAN_DATA_TYPE_FLOAT + + + + INT data. + + D3DX11_SCAN_DATA_TYPE_INT + + + + UINT data. + + D3DX11_SCAN_DATA_TYPE_UINT + + + + Scan opcodes. + + D3DX11_SCAN_OPCODE + + + + Add values. + + D3DX11_SCAN_OPCODE_ADD + + + + Take the minimum value. + + D3DX11_SCAN_OPCODE_MIN + + + + Take the maximum value. + + D3DX11_SCAN_OPCODE_MAX + + + + Multiply the values. + + D3DX11_SCAN_OPCODE_MUL + + + + Perform a logical AND on the values. + + D3DX11_SCAN_OPCODE_AND + + + + Perform a logical OR on the values. + + D3DX11_SCAN_OPCODE_OR + + + + Perform a logical XOR on the values. + + D3DX11_SCAN_OPCODE_XOR + + + + Direction to perform scan in. + + D3DX11_SCAN_DIRECTION + + + + Scan forward. + + D3DX11_SCAN_DIRECTION_FORWARD + + + + Scan backward. + + D3DX11_SCAN_DIRECTION_BACKWARD + + + + FFT data types. + + D3DX11_FFT_DATA_TYPE + + + + Real numbers. + + D3DX11_FFT_DATA_TYPE_REAL + + + + Complex numbers. + + D3DX11_FFT_DATA_TYPE_COMPLEX + + + + Number of dimensions for FFT data. + + D3DX11_FFT_DIM_MASK + + + + One dimension. + + D3DX11_FFT_DIM_MASK_1D + + + + Two dimensions. + + D3DX11_FFT_DIM_MASK_2D + + + + Three dimensions. + + D3DX11_FFT_DIM_MASK_3D + + + + FFT creation flags. + + D3DX11_FFT_CREATE_FLAG + + + + Do not AddRef or Release temp and precompute buffers, caller is responsible for holding references to these buffers. + + D3DX11_FFT_CREATE_FLAG_NO_PRECOMPUTE_BUFFERS + + + + None. + + None + + + + D3D11 Functions. + + + + Constant None. + + + + Load DLLs and bind functions + + + + + Creates a device that represents the display adapter. + + + This entry-point is supported by the Direct3D 11 runtime, which is available on Windows 7, Windows Server 2008 R2, and as an update to Windows Vista (KB971644). Set ppDevice and ppImmediateContext to NULL to determine which feature level is supported by looking at pFeatureLevel without creating a device. For an example, see {{How To: Create a Device and Immediate Context}}; to create a device and a swap chain at the same time, use . If you set the pAdapter parameter to a non-NULL value, you must also set the DriverType parameter to the D3D_DRIVER_TYPE_UNKNOWN value. If you set the pAdapter parameter to a non-NULL value and the DriverType parameter to the D3D_DRIVER_TYPE_HARDWARE value, D3D11CreateDevice returns an of E_INVALIDARG. Differences between Direct3D 10 and Direct3D 11: In Direct3D 10, the presence of pAdapter dictated which adapter to use and the DriverType could mismatch what the adapter was. In Direct3D 11, if you are trying to create a hardware or a software device, set pAdapter != NULL which constrains the other inputs to be: DriverType must be D3D_DRIVER_TYPE_UNKNOWN Software must be NULL. On the other hand, if pAdapter == NULL, the DriverType cannot be set to D3D_DRIVER_TYPE_UNKNOWN; it can be set to either: If DriverType == D3D_DRIVER_TYPE_SOFTWARE, Software cannot be NULL. If DriverType == D3D_DRIVER_TYPE_HARDWARE, the adapter used will be the default adapter, which is the first adapter that is enumerated by {{IDXGIFactory1::EnumAdapters}} ? + + A reference to the video adapter to use when creating a {{device}}. Pass NULL to use the default adapter, which is the first adapter that is enumerated by {{IDXGIFactory1::EnumAdapters}}. Note??Do not mix the use of DXGI 1.0 () and DXGI 1.1 () in an application. Use IDXGIFactory or IDXGIFactory1, but not both in an application. + The , which represents the driver type to create. + A handle to a DLL that implements a software rasterizer. If DriverType is D3D_DRIVER_TYPE_SOFTWARE, Software must not be NULL. Get the handle by calling {{LoadLibrary}}, {{LoadLibraryEx}} , or {{GetModuleHandle}}. + The runtime {{layers}} to enable (see ); values can be bitwise OR'd together. + A reference to an array of s, which determine the order of feature levels to attempt to create. Use default parameters to get the greatest feature level available. If pFeatureLevels is set to NULL, the following array of feature levels will be used: { D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0, D3D_FEATURE_LEVEL_9_3, D3D_FEATURE_LEVEL_9_2, D3D_FEATURE_LEVEL_9_1,}; + The number of elements in pFeatureLevels. + The SDK version; use D3D11_SDK_VERSION. + Returns the address of a reference to an object that represents the device created. + If successful, returns the first from the pFeatureLevels array which succeeded. Otherwise, returns 0. + Returns the address of a reference to an object that represents the device context. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT D3D11CreateDevice([In, Optional] IDXGIAdapter* pAdapter,[None] D3D_DRIVER_TYPE DriverType,[None] void* Software,[None] D3D11_CREATE_DEVICE_FLAG Flags,[In, Buffer, Optional] const D3D_FEATURE_LEVEL* pFeatureLevels,[None] int FeatureLevels,[None] int SDKVersion,[Out, Optional] ID3D11Device** ppDevice,[Out, Optional] D3D_FEATURE_LEVEL* pFeatureLevel,[Out, Optional] ID3D11DeviceContext** ppImmediateContext) + + + + Creates a device that represents the display adapter and a swap chain used for rendering. + + + This entry-point is supported by the Direct3D 11 runtime, which is available on Windows 7, Windows Server 2008 R2, and as an update to Windows Vista (KB971644). Also, see the remarks section in for details about input parameter dependencies. To create a device without creating a swap chain, use the function. If you set the pAdapter parameter to a non-NULL value, you must also set the DriverType parameter to the D3D_DRIVER_TYPE_UNKNOWN value. If you set the pAdapter parameter to a non-NULL value and the DriverType parameter to the D3D_DRIVER_TYPE_HARDWARE value, D3D11CreateDeviceAndSwapChain returns an of E_INVALIDARG. + + A reference to the video adapter to use when creating a {{device}}. Pass NULL to use the default adapter, which is the first adapter enumerated by {{IDXGIFactory1::EnumAdapters}}. Note??Do not mix the use of DXGI 1.0 () and DXGI 1.1 () in an application. Use IDXGIFactory or IDXGIFactory1, but not both in an application. + The , which represents the driver type to create. + A handle to a DLL that implements a software rasterizer. If DriverType is D3D_DRIVER_TYPE_SOFTWARE, Software must not be NULL. Get the handle by calling {{LoadLibrary}}, {{LoadLibraryEx}} , or {{GetModuleHandle}}. The value should be non-NULL when is D3D_DRIVER_TYPE_SOFTWARE and NULL otherwise. + The runtime {{layers}} to enable (see ); values can be bitwise OR'd together. + A reference to an array of s, which determine the order of feature levels to attempt to create. Use default parameters to get the greatest feature level available. If pFeatureLevels is set to NULL, the following array of feature levels will be used: { D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0, D3D_FEATURE_LEVEL_9_3, D3D_FEATURE_LEVEL_9_2, D3D_FEATURE_LEVEL_9_1,}; + The number of elements in pFeatureLevels. + The SDK version; use D3D11_SDK_VERSION. + A reference to a swap chain description (see ) that contains initialization parameters for the swap chain. + Returns the address of a reference to the object that represents the swap chain used for rendering. + Returns the address of a reference to an object that represents the device created. Supply NULL as an input to return the highest supported feature level in pFeatureLevel. + Returns a reference to a , which represents the first element in an array of feature levels supported by the device. + Returns the address of a reference to an object that represents the device context. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT D3D11CreateDeviceAndSwapChain([In, Optional] IDXGIAdapter* pAdapter,[None] D3D_DRIVER_TYPE DriverType,[None] void* Software,[None] D3D11_CREATE_DEVICE_FLAG Flags,[In, Buffer, Optional] const D3D_FEATURE_LEVEL* pFeatureLevels,[None] int FeatureLevels,[None] int SDKVersion,[In] const DXGI_SWAP_CHAIN_DESC* pSwapChainDesc,[Out, Optional] IDXGISwapChain** ppSwapChain,[Out, Optional] ID3D11Device** ppDevice,[Out, Optional] D3D_FEATURE_LEVEL* pFeatureLevel,[Out, Optional] ID3D11DeviceContext** ppImmediateContext) + + + + D3DX11 Functions. + + + + + Load DLLs and bind functions + + + + + No documentation. + + No documentation. + No documentation. + No documentation. + HRESULT D3DX11CheckVersion([None] int D3DSdkVersion,[None] int D3DX11SdkVersion) + + + + Retrieves information about a given image file. + + + This function supports both Unicode and ANSI strings. + + File name of image to retrieve information about. If UNICODE or _UNICODE are defined, this parameter type is LPCWSTR, otherwise, the type is LPCSTR. + Optional thread pump that can be used to load the info asynchronously. Can be NULL. See . + Pointer to a to be filled with the description of the data in the source file. + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + If the function succeeds, the return value is D3D_OK. If the function fails, the return value can be the following: D3DERR_INVALIDCALL + HRESULT D3DX11GetImageInfoFromFileW([None] const wchar_t* pSrcFile,[None] ID3DX11ThreadPump* pPump,[None] D3DX11_IMAGE_INFO* pSrcInfo,[None] HRESULT* pHResult) + + + + Retrieves information about a given image in a resource. + + + The compiler setting also determines the function version. If Unicode is defined, the function call resolves to D3DX11GetImageInfoFromResourceW. Otherwise, the function call resolves to D3DX11GetImageInfoFromResourceA because ANSI strings are being used. + + Module where the resource is loaded. Set this parameter to NULL to specify the module associated with the image that the operating system used to create the current process. + Pointer to a string that specifies the filename. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. See Remarks. + Optional thread pump that can be used to load the info asynchronously. Can be NULL. See . + Pointer to a D3DX11_IMAGE_INFO structure to be filled with the description of the data in the source file. + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + If the function succeeds, the return value is D3D_OK. If the function fails, the return value can be the following: D3DERR_INVALIDCALL + HRESULT D3DX11GetImageInfoFromResourceW([None] void* hSrcModule,[None] const wchar_t* pSrcResource,[None] ID3DX11ThreadPump* pPump,[None] D3DX11_IMAGE_INFO* pSrcInfo,[None] HRESULT* pHResult) + + + + Get information about an image already loaded into memory. + + Pointer to the image in memory. + Size of the image in memory, in bytes. + Optional thread pump that can be used to load the info asynchronously. Can be NULL. See . + Information about the image in memory. + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11GetImageInfoFromMemory([None] const void* pSrcData,[None] SIZE_T SrcDataSize,[None] ID3DX11ThreadPump* pPump,[None] D3DX11_IMAGE_INFO* pSrcInfo,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a file. + + A reference to the device (see ) that will use the resource. + Name of the file that contains the shader-resource view. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. + Optional. Identifies the characteristics of a texture (see ) when the data processor is created; set this to NULL to read the characteristics of a texture when the texture is loaded. + Pointer to a thread-pump interface (see ). If NULL is specified, this function will behave synchronously and will not return until it is finished. + Address of a reference to the shader-resource view (see ). + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11CreateShaderResourceViewFromFileW([None] ID3D11Device* pDevice,[None] const wchar_t* pSrcFile,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[None] ID3D11ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a texture resource from a file. + + A reference to the device (see ) that will use the resource. + The name of the file containing the resource. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. + Optional. Identifies the characteristics of a texture (see ) when the data processor is created; set this to NULL to read the characteristics of a texture when the texture is loaded. + A reference to a thread pump interface (see ). If NULL is specified, this function will behave synchronously and will not return until it is finished. + The address of a reference to the texture resource (see ). + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11CreateTextureFromFileW([None] ID3D11Device* pDevice,[None] const wchar_t* pSrcFile,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[Out] ID3D11Resource** ppTexture,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a resource. + + A reference to the device (see ) that will use the resource. + Handle to the resource module containing the shader-resource view. HMODULE can be obtained with {{GetModuleHandle Function}}. + Name of the shader resource view in hSrcModule. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. + Optional. Identifies the characteristics of a texture (see ) when the data processor is created; set this to NULL to read the characteristics of a texture when the texture is loaded. + A reference to a thread pump interface (see ). If NULL is specified, this function will behave synchronously and will not return until it is finished. + Address of a reference to the shader-resource view (see ). + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11CreateShaderResourceViewFromResourceW([None] ID3D11Device* pDevice,[None] void* hSrcModule,[None] const wchar_t* pSrcResource,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[None] ID3D11ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a texture from another resource. + + A reference to the device (see ) that will use the resource. + A handle to the source resource. HMODULE can be obtained with {{GetModuleHandle Function}}. + A string that contains the name of the source resource. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. + Optional. Identifies the characteristics of a texture (see ) when the data processor is created; set this to NULL to read the characteristics of a texture when the texture is loaded. + A reference to a thread pump interface (see ). If NULL is specified, this function will behave synchronously and will not return until it is finished. + The address of a reference to the texture resource (see ). + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11CreateTextureFromResourceW([None] ID3D11Device* pDevice,[None] void* hSrcModule,[None] const wchar_t* pSrcResource,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[Out] ID3D11Resource** ppTexture,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a file in memory. + + A reference to the device (see ) that will use the resource. + Pointer to the file in memory that contains the shader-resource view. + Size of the file in memory. + Optional. Identifies the characteristics of a texture (see ) when the data processor is created; set this to NULL to read the characteristics of a texture when the texture is loaded. + A reference to a thread pump interface (see ). If NULL is specified, this function will behave synchronously and will not return until it is finished. + Address of a reference to the newly created shader resource view. See . + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11CreateShaderResourceViewFromMemory([None] ID3D11Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[None] ID3D11ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a texture resource from a file residing in system memory. + + A reference to the device (see ) that will use the resource. + Pointer to the resource in system memory. + Size of the resource in system memory. + Optional. Identifies the characteristics of a texture (see ) when the data processor is created; set this to NULL to read the characteristics of a texture when the texture is loaded. + A reference to a thread pump interface (see ). If NULL is specified, this function will behave synchronously and will not return until it is finished. + Address of a reference to the created resource. See . + A reference to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11CreateTextureFromMemory([None] ID3D11Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[Out] ID3D11Resource** ppTexture,[None] HRESULT* pHResult) + + + + Load a texture from a texture. + + Pointer to the source texture. See . + Pointer to texture loading parameters. See . + Pointer to the destination texture. See . + No documentation. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11LoadTextureFromTexture([None] ID3D11DeviceContext* pContext,[None] ID3D11Resource* pSrcTexture,[None] D3DX11_TEXTURE_LOAD_INFO* pLoadInfo,[None] ID3D11Resource* pDstTexture) + + + + Generates mipmap chain using a particular texture filter. + + A reference to an object. + The texture object to be filtered. See . + The mipmap level whose data is used to generate the rest of the mipmap chain. + Flags controlling how each miplevel is filtered (or D3DX11_DEFAULT for D3DX11_FILTER_BOX). See . + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11FilterTexture([None] ID3D11DeviceContext* pContext,[None] ID3D11Resource* pTexture,[None] int SrcLevel,[None] int MipFilter) + + + + Save a texture to a file. + + A reference to an object. + Pointer to the texture to be saved. See . + The format the texture will be saved as (see ). D3DX11_IFF_DDS is the preferred format since it is the only option that supports all the formats in . + Name of the destination output file where the texture will be saved. If the compiler settings require Unicode, the data type LPCTSTR resolves to LPCWSTR. Otherwise, the data type resolves to LPCSTR. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}; use the return value to see if the DestFormat is supported. + HRESULT D3DX11SaveTextureToFileW([None] ID3D11DeviceContext* pContext,[None] ID3D11Resource* pSrcTexture,[None] D3DX11_IMAGE_FILE_FORMAT DestFormat,[None] const wchar_t* pDestFile) + + + + Save a texture to memory. + + A reference to an object. + Pointer to the texture to be saved. See . + The format the texture will be saved as. See . + Address of a reference to the memory containing the saved texture. + Optional. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11SaveTextureToMemory([None] ID3D11DeviceContext* pContext,[None] ID3D11Resource* pSrcTexture,[None] D3DX11_IMAGE_FILE_FORMAT DestFormat,[Out] ID3D10Blob** ppDestBuf,[None] int Flags) + + + + Converts a height map into a normal map. The (x,y,z) components of each normal are mapped to the (r,g,b) channels of the output texture. + + + This method computes the normal by using the central difference with a kernel size of 3x3. RGB channels in the destination contain biased (x,y,z) components of the normal. The central differencing denominator is hardcoded to 2.0. + + Pointer to an interface, representing the source height-map texture. + Pointer to an interface, representing the source height-map texture. + One or more D3DX_NORMALMAP flags that control generation of normal maps. + One D3DX_CHANNEL flag specifying the source of height information. + Constant value multiplier that increases (or decreases) the values in the normal map. Higher values usually make bumps more visible, lower values usually make bumps less visible. + Pointer to an interface, representing the destination texture. + If the function succeeds, the return value is D3D_OK. If the function fails, the return value can be the following value: D3DERR_INVALIDCALL. + HRESULT D3DX11ComputeNormalMap([None] ID3D11DeviceContext* pContext,[None] ID3D11Texture2D* pSrcTexture,[None] D3DX11_NORMALMAP_FLAG Flags,[None] D3DX11_CHANNEL_FLAG Channel,[None] float Amplitude,[None] ID3D11Texture2D* pDestTexture) + + + + Projects a function represented in a cube map into spherical harmonics. + + A reference to an object. + Order of the SH evaluation, generates Order^2 coefficients whose degree is Order-1. Valid range is between 2 and 6. + A reference to an that represents a cubemap that is going to be projected into spherical harmonics. + Output SH vector for red. + Output SH vector for green. + Output SH vector for blue. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11SHProjectCubeMap([None] ID3D11DeviceContext* pContext,[In] int Order,[None] ID3D11Texture2D* pCubeMap,[Out, Buffer] float* pROut,[Out, Buffer, Optional] float* pGOut,[Out, Buffer, Optional] float* pBOut) + + + + D3DCSX Functions. + + + + + Load DLLs and bind functions + + + + + Creates a scan context. + + The the scan is associated with. + Maximum single scan size, in elements (FLOAT, UINT, or INT) + Maximum number of scans in multiscan. + Pointer to a reference that will be set to the created interface object. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11CreateScan([In] ID3D11DeviceContext* pDeviceContext,[None] int MaxElementScanSize,[None] int MaxScanCount,[Out] ID3DX11Scan** ppScan) + + + + Creates a segmented scan context. + + Pointer to an interface. + Maximum single scan size, in elements (FLOAT, UINT, or INT). + Pointer to a reference that will be set to the created interface object. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11CreateSegmentedScan([In] ID3D11DeviceContext* pDeviceContext,[None] int MaxElementScanSize,[Out] ID3DX11SegmentedScan** ppScan) + + + + Creates an ID3DX11FFT COM interface object. + + Pointer to the interface to use for the FFT. + Pointer to a structure that describes the shape of the FFT data as well as the scaling factors that should be used for forward and inverse transforms. + Flag affecting the behavior of the FFT, can be 0 or a combination of flags from . + Pointer to a struct that will be filled out with buffer requirements for the FFT. + Pointer to an interface reference that will be set the created interface object. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11CreateFFT([None] ID3D11DeviceContext* pDeviceContext,[In] const D3DX11_FFT_DESC* pDesc,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates an ID3DX11FFT COM interface object. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Flag affecting the behavior of the FFT, can be 0 or a combination of flags from . + Pointer to a struct that will be filled out with buffer requirements for the FFT. + Pointer to an interface reference that will be set the created interface object. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11CreateFFT1DReal([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates an ID3DX11FFT COM interface object. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Flag affecting the behavior of the FFT, can be 0 or a combination of flags from . + Pointer to a struct that will be filled out with buffer requirements for the FFT. + Pointer to an interface reference that will be set the created interface object. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11CreateFFT1DComplex([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates an ID3DX11FFT COM interface object. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Length of the second dimension of the FFT. + Flag affecting the behavior of the FFT, can be 0 or a combination of flags from . + Pointer to a struct that will be filled out with buffer requirements for the FFT. + Pointer to an interface reference that will be set the created interface object. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11CreateFFT2DReal([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Y,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates an ID3DX11FFT COM interface object. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Length of the second dimension of the FFT. + Flag affecting the behavior of the FFT, can be 0 or a combination of flags from . + Pointer to a struct that will be filled out with buffer requirements for the FFT. + Pointer to an interface reference that will be set the created interface object. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11CreateFFT2DComplex([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Y,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates an ID3DX11FFT COM interface object. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Length of the second dimension of the FFT. + Length of the third dimension of the FFT. + Flag affecting the behavior of the FFT, can be 0 or a combination of flags from . + Pointer to a struct that will be filled out with buffer requirements for the FFT. + Pointer to an interface reference that will be set the created interface object. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11CreateFFT3DReal([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Y,[None] int Z,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + Creates an ID3DX11FFT COM interface object. + + Pointer to the interface to use for the FFT. + Length of the first dimension of the FFT. + Length of the second dimension of the FFT. + Length of the third dimension of the FFT. + Flag affecting the behavior of the FFT, can be 0 or a combination of flags from . + Pointer to a struct that will be filled out with buffer requirements for the FFT. + Pointer to an interface reference that will be set the created interface object. + The return value is one of the values listed in {{Direct3D 11 Return Codes}}. + HRESULT D3DX11CreateFFT3DComplex([None] ID3D11DeviceContext* pDeviceContext,[None] int X,[None] int Y,[None] int Z,[None] int Flags,[Out] D3DX11_FFT_BUFFER_INFO* pBufferInfo,[Out] ID3DX11FFT** ppFFT) + + + + A rasterizer-state interface accesses rasterizer state for the rasterizer stage. + + ID3D11RasterizerState + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the properties of a rasterizer-state object. + + Pointer to a rasterizer-state description (see ). + void ID3D11RasterizerState::GetDesc([Out] D3D11_RASTERIZER_DESC* pDesc) + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Get the properties of a rasterizer-state object. + + void ID3D11RasterizerState::GetDesc([Out] D3D11_RASTERIZER_DESC* pDesc) + + + + A 1D texture interface accesses texel data, which is structured memory. + + ID3D11Texture1D + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the properties of the texture resource. + + Pointer to a resource description (see ). + void ID3D11Texture1D::GetDesc([Out] D3D11_TEXTURE1D_DESC* pDesc) + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + The initial texture data. + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + An array of initial texture data for each subresource. + + + + Get the properties of the texture resource. + + void ID3D11Texture1D::GetDesc([Out] D3D11_TEXTURE1D_DESC* pDesc) + + + + A 2D texture interface manages texel data, which is structured memory. + + ID3D11Texture2D + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the properties of the texture resource. + + Pointer to a resource description (see ). + void ID3D11Texture2D::GetDesc([Out] D3D11_TEXTURE2D_DESC* pDesc) + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + The initial texture data. + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + An array of initial texture data for each subresource. + + + + Converts a height map into a normal map. The (x,y,z) components of each normal are mapped to the (r,g,b) channels of the output texture. + + The device used to create the normal map. + The source height map texture. + The destination texture. + One or more flags that control generation of normal maps. + One or more flag specifying the source of height information. + Constant value multiplier that increases (or decreases) the values in the normal map. Higher values usually make bumps more visible, lower values usually make bumps less visible. + A object describing the result of the operation. + + + + Get the properties of the texture resource. + + void ID3D11Texture2D::GetDesc([Out] D3D11_TEXTURE2D_DESC* pDesc) + + + + A 3D texture interface accesses texel data, which is structured memory. + + ID3D11Texture3D + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the properties of the texture resource. + + Pointer to a resource description (see ). + void ID3D11Texture3D::GetDesc([Out] D3D11_TEXTURE3D_DESC* pDesc) + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + The initial texture data. + + + + Initializes a new instance of the class. + + The device with which to associate the texture. + The description of the texture. + An array of initial texture data for each subresource. + + + + Get the properties of the texture resource. + + void ID3D11Texture3D::GetDesc([Out] D3D11_TEXTURE3D_DESC* pDesc) + + + + A shader-resource-view interface specifies the subresources a shader can access during rendering. Examples of shader resources include a constant buffer, a texture buffer, a texture or a sampler. + + ID3D11ShaderResourceView + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the shader resource view's description. + + A reference to a structure to be filled with data about the shader resource view. + void ID3D11ShaderResourceView::GetDesc([Out] D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc) + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the ShaderResource flag. + ID3D11Device::CreateShaderResourceView + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the ShaderResource flag. + A structure describing the to be created. + ID3D11Device::CreateShaderResourceView + + + + Create a shader-resource view from a file. Read the characteristics of a texture when the texture is loaded. + + A reference to the device (see ) that will use the resource. + Name of the file that contains the shader-resource view. + Returns a reference to the shader-resource view (see ). + HRESULT D3DX11CreateShaderResourceViewFromFileW([None] ID3D10Device* pDevice,[None] const wchar_t* pSrcFile,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a file. + + A reference to the device (see ) that will use the resource. + Name of the file that contains the shader-resource view. + Identifies the characteristics of a texture (see ) when the data processor is created. + Returns a reference to the shader-resource view (see ). + HRESULT D3DX11CreateShaderResourceViewFromFileW([None] ID3D10Device* pDevice,[None] const wchar_t* pSrcFile,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a file in memory. + + A reference to the device (see ) that will use the resource. + Pointer to a memory location that contains the shader-resource view. + Returns a reference to the shader-resource view (see ). + HRESULT D3DX11CreateShaderResourceViewFromMemory([None] ID3D10Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a file in memory. + + A reference to the device (see ) that will use the resource. + Pointer to a memory location that contains the shader-resource view. + Identifies the characteristics of a texture (see ) when the data processor is created. + Returns a reference to the shader-resource view (see ). + HRESULT D3DX11CreateShaderResourceViewFromMemory([None] ID3D10Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a file in a stream.. + + A reference to the device (see ) that will use the resource. + Pointer to the file in memory that contains the shader-resource view. + Size of the file to read from the stream + Returns a reference to the shader-resource view (see ). + HRESULT D3DX11CreateShaderResourceViewFromMemory([None] ID3D10Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Create a shader-resource view from a file in a stream.. + + A reference to the device (see ) that will use the resource. + Pointer to the file in memory that contains the shader-resource view. + Size of the file to read from the stream + Identifies the characteristics of a texture (see ) when the data processor is created. + Returns a reference to the shader-resource view (see ). + HRESULT D3DX11CreateShaderResourceViewFromMemory([None] ID3D10Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult) + + + + Get the shader resource view's description. + + void ID3D11ShaderResourceView::GetDesc([Out] D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc) + + + + A render-target-view interface identifies the render-target subresources that can be accessed during rendering. + + ID3D11RenderTargetView + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the properties of a render target view. + + Pointer to the description of a render target view (see ). + void ID3D11RenderTargetView::GetDesc([Out] D3D11_RENDER_TARGET_VIEW_DESC* pDesc) + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the RenderTarget flag. + ID3D11Device::CreateRenderTargetView + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the RenderTarget flag. + A structure describing the to be created. + ID3D11Device::CreateRenderTargetView + + + + Get the properties of a render target view. + + void ID3D11RenderTargetView::GetDesc([Out] D3D11_RENDER_TARGET_VIEW_DESC* pDesc) + + + + A view interface specifies the parts of a resource the pipeline can access during rendering. + + ID3D11UnorderedAccessView + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a description of the resource. + + + + Pointer to a resource description (see .) + void ID3D11UnorderedAccessView::GetDesc([Out] D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc) + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the UnorderedAccess flag. + ID3D11Device::CreateUnorderedAccessView + + + + Creates a for accessing resource data. + + The device to use when creating this . + The resource that represents the render-target surface. This surface must have been created with the UnorderedAccess flag. + A structure describing the to be created. + ID3D11Device::CreateUnorderedAccessView + + + + Get a description of the resource. + + + + void ID3D11UnorderedAccessView::GetDesc([Out] D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc) + + + + A vertex-shader interface manages an executable program (a vertex shader) that controls the vertex-shader stage. + + ID3D11VertexShader + + + + Initializes a new instance of the class. + + The native pointer. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + A dynamic class linkage interface. + + + + A hull-shader interface manages an executable program (a hull shader) that controls the hull-shader stage. + + ID3D11HullShader + + + + Initializes a new instance of the class. + + The native pointer. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + A dynamic class linkage interface. + + + + A geometry-shader interface manages an executable program (a geometry shader) that controls the geometry-shader stage. + + ID3D11GeometryShader + + + + Initializes a new instance of the class. + + The native pointer. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + A dynamic class linkage interface. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + An array of instances describing the layout of the output buffers. + An array of buffer strides; each stride is the size of an element for that buffer. + The index number of the stream to be sent to the rasterizer stage. Set to NoRasterizedStream if no stream is to be rasterized. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + An array of instances describing the layout of the output buffers. + An array of buffer strides; each stride is the size of an element for that buffer. + The index number of the stream to be sent to the rasterizer stage. Set to NoRasterizedStream if no stream is to be rasterized. + A dynamic class linkage interface. + + + + A pixel-shader interface manages an executable program (a pixel shader) that controls the pixel-shader stage. + + ID3D11PixelShader + + + + Initializes a new instance of the class. + + The native pointer. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + + + + Initializes a new instance of the class. + + The device used to create the shader. + The compiled shader bytecode. + A dynamic class linkage interface. + + + + An input-layout interface accesses the input data for the input-assembler stage. + + ID3D11InputLayout + + + + Initializes a new instance of the class. + + The native pointer. + + + + Initializes a new instance of the object to describe the + input-buffer data for the input-assembler stage. + + ID3D11Device::CreateInputLayout + The device used to create the layout. + An array of input elements describing the layout of the input data. + The compiled shader used to validate the input elements. + + + + Initializes a new instance of the object to describe the + input-buffer data for the input-assembler stage. + + ID3D11Device::CreateInputLayout + The device used to create the layout. + An array of input elements describing the layout of the input data. + The shader signature used to validate the input elements. + + + + A sampler-state interface accesses sampler state for a texture. + + ID3D11SamplerState + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get the sampler state. + + A reference to the sampler state (see ). + void ID3D11SamplerState::GetDesc([Out] D3D11_SAMPLER_DESC* pDesc) + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The state description. + The newly created object. + + + + Get the sampler state. + + void ID3D11SamplerState::GetDesc([Out] D3D11_SAMPLER_DESC* pDesc) + + + + A query interface queries information from the GPU. + + ID3D11Query + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a query description. + + Pointer to a query description (see ). + void ID3D11Query::GetDesc([Out] D3D11_QUERY_DESC* pDesc) + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The query description. + The newly created object. + + + + Get a query description. + + void ID3D11Query::GetDesc([Out] D3D11_QUERY_DESC* pDesc) + + + + A predicate interface determines whether geometry should be processed depending on the results of a previous draw call. + + ID3D11Predicate + + + + Initializes a new instance of the class. + + The native pointer. + + + + Constructs a new based on the specified description. + + The device with which to associate the state object. + The query description. + The newly created object. + + + + The ID3D11CommandList interface encapsulates a list of graphics commands for play back. + + ID3D11CommandList + + + + Initializes a new instance of the class. + + The native pointer. + + + + Gets the initialization flags associated with the deferred context that created the command list. + + + The GetContextFlags method gets the flags that were supplied to the ContextFlags parameter of ; however, the context flag is reserved for future use. + + The context flag is reserved for future use and is always 0. + int ID3D11CommandList::GetContextFlags() + + + + Gets the initialization flags associated with the deferred context that created the command list. + + + The GetContextFlags method gets the flags that were supplied to the ContextFlags parameter of ; however, the context flag is reserved for future use. + + int ID3D11CommandList::GetContextFlags() + + + + Note??The ID3D11SwitchToRef interface and its methods are not supported in Direct3D 11. + + ID3D11SwitchToRef + + + + Initializes a new instance of the class. + + The native pointer. + + + + Note??The interface and its methods are not supported in Direct3D 11. + + Reserved. + Reserved. + BOOL ID3D11SwitchToRef::SetUseRef([None] BOOL UseRef) + + + + Note??The interface and its methods are not supported in Direct3D 11. + + Reserved. + BOOL ID3D11SwitchToRef::GetUseRef() + + + + Note??The interface and its methods are not supported in Direct3D 11. + + BOOL ID3D11SwitchToRef::GetUseRef() + + + + An information-queue interface stores, retrieves, and filters debug messages. The queue consists of a message queue, an optional storage filter stack, and a optional retrieval filter stack. + + ID3D11InfoQueue + + + + Initializes a new instance of the class. + + The native pointer. + + + + Set the maximum number of messages that can be added to the message queue. + + + When the number of messages in the message queue has reached the maximum limit, new messages coming in will push old messages out. + + Maximum number of messages that can be added to the message queue. -1 means no limit. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::SetMessageCountLimit([In] __int64 MessageCountLimit) + + + + Clear all messages from the message queue. + + void ID3D11InfoQueue::ClearStoredMessages() + + + + Get a message from the message queue. + + + This method does not remove any messages from the message queue. This method gets messages from the message queue after an optional retrieval filter has been applied. Applications should call this method twice to retrieve a message - first to obtain the size of the message and second to get the message. Here is a typical example: + // Get the size of the message + SIZE_T messageLength = 0; + HRESULT hr = pInfoQueue->GetMessage(0, NULL, &messageLength); // Allocate space and get the message + D3D11_MESSAGE * pMessage = (D3D11_MESSAGE*)malloc(messageLength); + hr = pInfoQueue->GetMessage(0, pMessage, &messageLength); + + For an overview see {{Information Queue Overview}}. + + Index into message queue after an optional retrieval filter has been applied. This can be between 0 and the number of messages in the message queue that pass through the retrieval filter (which can be obtained with ). 0 is the message at the front of the message queue. + Returned message (see ). + Size of pMessage in bytes, including the size of the message string that the pMessage points to. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::GetMessage([In] __int64 MessageIndex,[Out, Buffer, Optional] D3D11_MESSAGE* pMessage,[InOut] SIZE_T* pMessageByteLength) + + + + Get the number of messages that were allowed to pass through a storage filter. + + Number of messages allowed by a storage filter. + __int64 ID3D11InfoQueue::GetNumMessagesAllowedByStorageFilter() + + + + Get the number of messages that were denied passage through a storage filter. + + Number of messages denied by a storage filter. + __int64 ID3D11InfoQueue::GetNumMessagesDeniedByStorageFilter() + + + + Get the number of messages currently stored in the message queue. + + Number of messages currently stored in the message queue. + __int64 ID3D11InfoQueue::GetNumStoredMessages() + + + + Get the number of messages that are able to pass through a retrieval filter. + + Number of messages allowed by a retrieval filter. + __int64 ID3D11InfoQueue::GetNumStoredMessagesAllowedByRetrievalFilter() + + + + Get the number of messages that were discarded due to the message count limit. + + + Get and set the message count limit with and , respectively. + + Number of messages discarded. + __int64 ID3D11InfoQueue::GetNumMessagesDiscardedByMessageCountLimit() + + + + Get the maximum number of messages that can be added to the message queue. + + + When the number of messages in the message queue has reached the maximum limit, new messages coming in will push old messages out. + + Maximum number of messages that can be added to the queue. -1 means no limit. + __int64 ID3D11InfoQueue::GetMessageCountLimit() + + + + Add storage filters to the top of the storage-filter stack. + + Array of storage filters (see ). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::AddStorageFilterEntries([In] D3D11_INFO_QUEUE_FILTER* pFilter) + + + + Get the storage filter at the top of the storage-filter stack. + + Storage filter at the top of the storage-filter stack. + Size of the storage filter in bytes. If pFilter is NULL, the size of the storage filter will be output to this parameter. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::GetStorageFilter([Out, Buffer, Optional] D3D11_INFO_QUEUE_FILTER* pFilter,[InOut] SIZE_T* pFilterByteLength) + + + + Remove a storage filter from the top of the storage-filter stack. + + void ID3D11InfoQueue::ClearStorageFilter() + + + + Push an empty storage filter onto the storage-filter stack. + + + An empty storage filter allows all messages to pass through. + + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::PushEmptyStorageFilter() + + + + Push a copy of storage filter currently on the top of the storage-filter stack onto the storage-filter stack. + + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::PushCopyOfStorageFilter() + + + + Push a storage filter onto the storage-filter stack. + + Pointer to a storage filter (see ). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::PushStorageFilter([In] D3D11_INFO_QUEUE_FILTER* pFilter) + + + + Pop a storage filter from the top of the storage-filter stack. + + void ID3D11InfoQueue::PopStorageFilter() + + + + Get the size of the storage-filter stack in bytes. + + Size of the storage-filter stack in bytes. + int ID3D11InfoQueue::GetStorageFilterStackSize() + + + + Add storage filters to the top of the retrieval-filter stack. + + + The following code example shows how to use ID3D11InfoQueue::AddRetrievalFilterEntries: + D3D11_MESSAGE_CATEGORY cats[] = { ..., ..., ... }; + D3D11_MESSAGE_SEVERITY sevs[] = { ..., ..., ... }; + UINT ids[] = { ..., ..., ... }; D3D11_INFO_QUEUE_FILTER filter; + memset( &filter, 0, sizeof(filter) ); // To set the type of messages to allow, + // set filter.AllowList as follows: + filter.AllowList.NumCategories = sizeof(cats / sizeof(D3D11_MESSAGE_CATEGORY)); + filter.AllowList.pCategoryList = cats; + filter.AllowList.NumSeverities = sizeof(sevs / sizeof(D3D11_MESSAGE_SEVERITY)); + filter.AllowList.pSeverityList = sevs; + filter.AllowList.NumIDs = sizeof(ids) / sizeof(UINT); + filter.AllowList.pIDList = ids; // To set the type of messages to deny, set filter.DenyList + // similarly to the preceding filter.AllowList. // The following single call sets all of the preceding information. + hr = infoQueue->AddRetrievalFilterEntries( &filter ); + + + + Array of retrieval filters (see ). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::AddRetrievalFilterEntries([In] D3D11_INFO_QUEUE_FILTER* pFilter) + + + + Get the retrieval filter at the top of the retrieval-filter stack. + + Retrieval filter at the top of the retrieval-filter stack. + Size of the retrieval filter in bytes. If pFilter is NULL, the size of the retrieval filter will be output to this parameter. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::GetRetrievalFilter([Out, Buffer, Optional] D3D11_INFO_QUEUE_FILTER* pFilter,[InOut] SIZE_T* pFilterByteLength) + + + + Remove a retrieval filter from the top of the retrieval-filter stack. + + void ID3D11InfoQueue::ClearRetrievalFilter() + + + + Push an empty retrieval filter onto the retrieval-filter stack. + + + An empty retrieval filter allows all messages to pass through. + + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::PushEmptyRetrievalFilter() + + + + Push a copy of retrieval filter currently on the top of the retrieval-filter stack onto the retrieval-filter stack. + + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::PushCopyOfRetrievalFilter() + + + + Push a retrieval filter onto the retrieval-filter stack. + + Pointer to a retrieval filter (see ). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::PushRetrievalFilter([In] D3D11_INFO_QUEUE_FILTER* pFilter) + + + + Pop a retrieval filter from the top of the retrieval-filter stack. + + void ID3D11InfoQueue::PopRetrievalFilter() + + + + Get the size of the retrieval-filter stack in bytes. + + Size of the retrieval-filter stack in bytes. + int ID3D11InfoQueue::GetRetrievalFilterStackSize() + + + + Add a debug message to the message queue and send that message to debug output. + + + This method is used by the runtime's internal mechanisms to add debug messages to the message queue and send them to debug output. For applications to add their own custom messages to the message queue and send them to debug output, call . + + Category of a message (see ). + Severity of a message (see ). + Unique identifier of a message (see ). + User-defined message. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::AddMessage([In] D3D11_MESSAGE_CATEGORY Category,[In] D3D11_MESSAGE_SEVERITY Severity,[In] D3D11_MESSAGE_ID ID,[In] const char* pDescription) + + + + Add a user-defined message to the message queue and send that message to debug output. + + Severity of a message (see ). + Message string. + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::AddApplicationMessage([In] D3D11_MESSAGE_SEVERITY Severity,[In] const char* pDescription) + + + + Set a message category to break on when a message with that category passes through the storage filter. + + Message category to break on (see ). + Turns this breaking condition on or off (true for on, false for off). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::SetBreakOnCategory([In] D3D11_MESSAGE_CATEGORY Category,[In] BOOL bEnable) + + + + Set a message severity level to break on when a message with that severity level passes through the storage filter. + + A , which represents a message severity level to break on. + Turns this breaking condition on or off (true for on, false for off). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::SetBreakOnSeverity([In] D3D11_MESSAGE_SEVERITY Severity,[In] BOOL bEnable) + + + + Set a message identifier to break on when a message with that identifier passes through the storage filter. + + Message identifier to break on (see ). + Turns this breaking condition on or off (true for on, false for off). + This method returns one of the following {{Direct3D 11 Return Codes}}. + HRESULT ID3D11InfoQueue::SetBreakOnID([In] D3D11_MESSAGE_ID ID,[In] BOOL bEnable) + + + + Get a message category to break on when a message with that category passes through the storage filter. + + Message category to break on (see ). + Whether this breaking condition is turned on or off (true for on, false for off). + BOOL ID3D11InfoQueue::GetBreakOnCategory([In] D3D11_MESSAGE_CATEGORY Category) + + + + Get a message severity level to break on when a message with that severity level passes through the storage filter. + + Message severity level to break on (see ). + Whether this breaking condition is turned on or off (true for on, false for off). + BOOL ID3D11InfoQueue::GetBreakOnSeverity([In] D3D11_MESSAGE_SEVERITY Severity) + + + + Get a message identifier to break on when a message with that identifier passes through the storage filter. + + Message identifier to break on (see ). + Whether this breaking condition is turned on or off (true for on, false for off). + BOOL ID3D11InfoQueue::GetBreakOnID([In] D3D11_MESSAGE_ID ID) + + + + Set a boolean that turns the debug output on or off. + + + This will stop messages that pass the storage filter from being printed out in the debug output, however those messages will still be added to the message queue. + + Disable/Enable the debug output (TRUE to disable or mute the output, FALSE to enable the output). + void ID3D11InfoQueue::SetMuteDebugOutput([In] BOOL bMute) + + + + Get a boolean that turns the debug output on or off. + + Whether the debug output is on or off (true for on, false for off). + BOOL ID3D11InfoQueue::GetMuteDebugOutput() + + + + Get the maximum number of messages that can be added to the message queue. + + + When the number of messages in the message queue has reached the maximum limit, new messages coming in will push old messages out. + + __int64 ID3D11InfoQueue::GetMessageCountLimit() + + + + Get the number of messages that were allowed to pass through a storage filter. + + __int64 ID3D11InfoQueue::GetNumMessagesAllowedByStorageFilter() + + + + Get the number of messages that were denied passage through a storage filter. + + __int64 ID3D11InfoQueue::GetNumMessagesDeniedByStorageFilter() + + + + Get the number of messages currently stored in the message queue. + + __int64 ID3D11InfoQueue::GetNumStoredMessages() + + + + Get the number of messages that are able to pass through a retrieval filter. + + __int64 ID3D11InfoQueue::GetNumStoredMessagesAllowedByRetrievalFilter() + + + + Get the number of messages that were discarded due to the message count limit. + + + Get and set the message count limit with and , respectively. + + __int64 ID3D11InfoQueue::GetNumMessagesDiscardedByMessageCountLimit() + + + + Get the size of the storage-filter stack in bytes. + + int ID3D11InfoQueue::GetStorageFilterStackSize() + + + + Get the size of the retrieval-filter stack in bytes. + + int ID3D11InfoQueue::GetRetrievalFilterStackSize() + + + + Get a boolean that turns the debug output on or off. + + BOOL ID3D11InfoQueue::GetMuteDebugOutput() + + + + Scan context. + + ID3DX11Scan + + + + Initializes a new instance of the class. + + The native pointer. + + + + Sets which direction to perform scans in. + + + SetScanDirection sets the direction and will performed scans in. + + Direction to perform scans in. See . + Returns one of the return codes described in the topic {{Direct3D 11 Return Codes}}. + HRESULT ID3DX11Scan::SetScanDirection([None] D3DX11_SCAN_DIRECTION Direction) + + + + Performs an unsegmented scan of a sequence. + + + You must point the parameters pSrc and pDst to typed buffers (and not to raw or structured buffers). For information about buffer types, see {{Types of Resources}}. The format of these typed buffers must be , DXGI_FORMAT_R32_UINT, or DXGI_FORMAT_R32_INT. In addition, the format of these typed buffers must match the scan data type that you specify in the ElementType parameter. For example, if the scan data type is , the buffer formats must be DXGI_FORMAT_R32_UINT. + + The type of element in the sequence. See for more information. + The binary operation to perform. See for more information. + Size of scan in elements. + Input sequence on the device. Set pSrc and pDst to the same value for in-place scans. + Output sequence on the device. + Returns one of the return codes described in the topic {{Direct3D 11 Return Codes}}. + HRESULT ID3DX11Scan::Scan([None] D3DX11_SCAN_DATA_TYPE ElementType,[None] D3DX11_SCAN_OPCODE OpCode,[None] int ElementScanSize,[In] ID3D11UnorderedAccessView* pSrc,[In] ID3D11UnorderedAccessView* pDst) + + + + Performs a multiscan of a sequence. + + + You must point the parameters pSrc and pDst to typed buffers (and not to raw or structured buffers). For information about buffer types, see {{Types of Resources}}. The format of these typed buffers must be , DXGI_FORMAT_R32_UINT, or DXGI_FORMAT_R32_INT. In addition, the format of these typed buffers must match the scan data type that you specify in the ElementType parameter. For example, if the scan data type is , the buffer formats must be DXGI_FORMAT_R32_UINT. + + The type of element in the sequence. See for more information. + The binary operation to perform. See for more information. + Size of scan in elements. + Pitch of the next scan in elements. + Number of scans in the multiscan. + Input sequence on the device. Set pSrc and pDst to the same value for in-place scans. + Output sequence on the device. + Returns one of the return codes described in the topic {{Direct3D 11 Return Codes}}. + HRESULT ID3DX11Scan::Multiscan([None] D3DX11_SCAN_DATA_TYPE ElementType,[None] D3DX11_SCAN_OPCODE OpCode,[None] int ElementScanSize,[None] int ElementScanPitch,[None] int ScanCount,[In] ID3D11UnorderedAccessView* pSrc,[In] ID3D11UnorderedAccessView* pDst) + + + + Creates a scan context. + + The the scan is associated with. + Maximum single scan size, in elements (FLOAT, UINT, or INT) + Maximum number of scans in multiscan. + HRESULT D3DX11CreateScan([In] ID3D11DeviceContext* pDeviceContext,[None] int MaxElementScanSize,[None] int MaxScanCount,[Out] ID3DX11Scan** ppScan) + + + + Segmented scan context. + + ID3DX11SegmentedScan + + + + Initializes a new instance of the class. + + The native pointer. + + + + Sets which direction to perform scans in. + + + SetScanDirection sets the direction will performed scans in. + + Direction to perform scans in. See . + Returns one of the return codes described in the topic {{Direct3D 11 Return Codes}}. + HRESULT ID3DX11SegmentedScan::SetScanDirection([None] D3DX11_SCAN_DIRECTION Direction) + + + + Performs a segmented scan of a sequence. + + + You must point the parameters pSrc and pDst to typed buffers (and not to raw or structured buffers). For information about buffer types, see {{Types of Resources}}. The format of these typed buffers must be , DXGI_FORMAT_R32_UINT, or DXGI_FORMAT_R32_INT. In addition, the format of these typed buffers must match the scan data type that you specify in the ElementType parameter. For example, if the scan data type is , the buffer formats must be DXGI_FORMAT_R32_UINT. The format of the resource view to which the pSrcElementFlags parameter points must be . + + The type of element in the sequence. See for more information. + The binary operation to perform. See for more information. + Size of scan in elements. + Input sequence on the device. Set pSrc and pDst to the same value for in-place scans. + Compact array of bits with one bit per element of pSrc. A set value indicates the start of a new segment. + Output sequence on the device. + Returns one of the return codes described in the topic {{Direct3D 11 Return Codes}}. + HRESULT ID3DX11SegmentedScan::SegScan([None] D3DX11_SCAN_DATA_TYPE ElementType,[None] D3DX11_SCAN_OPCODE OpCode,[None] int ElementScanSize,[In, Optional] ID3D11UnorderedAccessView* pSrc,[In] ID3D11UnorderedAccessView* pSrcElementFlags,[In] ID3D11UnorderedAccessView* pDst) + + + + Creates a segmented scan context. + + Pointer to an interface. + Maximum single scan size, in elements (FLOAT, UINT, or INT). + HRESULT D3DX11CreateSegmentedScan([In] ID3D11DeviceContext* pDeviceContext,[None] int MaxElementScanSize,[Out] ID3DX11SegmentedScan** ppScan) + + + + A description of a single element for the input-assembler stage. + + + An input-layout object contains an array of structures, each structure defines one element being read from an input slot. Create an input-layout object by calling . For an example, see Create an input-layout object. + + D3D11_INPUT_ELEMENT_DESC + + + + The HLSL semantic associated with this element in a shader input-signature. + + const char* SemanticName + + + + The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic name matrix, however each of the four component would have different semantic indices (0, 1, 2, and 3). + + int SemanticIndex + + + + The data type of the element data. See . + + DXGI_FORMAT Format + + + + An integer value that identifies the input-assembler (see input slot). Valid values are between 0 and 15, defined in D3D11.h. + + int InputSlot + + + + Optional. Offset (in bytes) between each element. Use D3D11_APPEND_ALIGNED_ELEMENT for convenience to define the current element directly after the previous one, including any packing if necessary. + + int AlignedByteOffset + + + + Identifies the input data class for a single input slot (see ). + + D3D11_INPUT_CLASSIFICATION InputSlotClass + + + + The number of instances to draw using the same per-instance data before advancing in the buffer by one element. This value must be 0 for an element that contains per-vertex data (the slot class is set to D3D11_INPUT_PER_VERTEX_DATA). + + int InstanceDataStepRate + + + + Initializes a new instance of the struct. + + The HLSL semantic associated with this element in a shader input-signature. + The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic name matrix, however each of the four component would have different semantic indices (0, 1, 2, and 3). + The data type of the element data. + Offset (in bytes) between each element. Use AppendAligned for convenience to define the current element directly after the previous one, including any packing if necessary. + An integer value that identifies the input-assembler. Valid values are between 0 and 15. + Identifies the input data class for a single input slot. + The number of instances to draw using the same per-instance data before advancing in the buffer by one element. This value must be 0 for an element that contains per-vertex data. + + + + Initializes a new instance of the struct. + + The HLSL semantic associated with this element in a shader input-signature. + The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic name matrix, however each of the four component would have different semantic indices (0, 1, 2, and 3). + The data type of the element data. + Offset (in bytes) between each element. Use AppendAligned for convenience to define the current element directly after the previous one, including any packing if necessary. + An integer value that identifies the input-assembler. Valid values are between 0 and 15. + + + + Initializes a new instance of the struct. + + The HLSL semantic associated with this element in a shader input-signature. + The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic name matrix, however each of the four component would have different semantic indices (0, 1, 2, and 3). + The data type of the element data. + An integer value that identifies the input-assembler. Valid values are between 0 and 15. + + + + Returns a value that can be used for the offset parameter of an InputElement to indicate that the element + should be aligned directly after the previous element, including any packing if neccessary. + + A value used to align input elements. + D3D11_APPEND_ALIGNED_ELEMENT + + + + Description of a vertex element in a vertex buffer in an output slot. + + D3D11_SO_DECLARATION_ENTRY + + + + Zero-based, stream number. + + int Stream + + + + Type of output element; possible values include: "POSITION", "NORMAL", or "TEXCOORD0". Note that if SemanticName is NULL then ComponentCount can be greater than 4 and the described entry will be a gap in the stream out where no data will be written. + + const char* SemanticName + + + + Output element's zero-based index. Should be used if, for example, you have more than one texture coordinate stored in each vertex. + + int SemanticIndex + + + + Which component of the entry to begin writing out to. Valid values are 0 to 3. For example, if you only wish to output to the y and z components of a position, then StartComponent should be 1 and ComponentCount should be 2. + + byte StartComponent + + + + The number of components of the entry to write out to. Valid values are 1 to 4. For example, if you only wish to output to the y and z components of a position, then StartComponent should be 1 and ComponentCount should be 2. Note that if SemanticName is NULL then ComponentCount can be greater than 4 and the described entry will be a gap in the stream out where no data will be written. + + byte ComponentCount + + + + The associated stream output buffer that is bound to the pipeline (see ). The valid range for OutputSlot is 0 to 3. + + byte OutputSlot + + + + Defines the dimensions of a viewport. + + + In all cases, Width and Height must be >= 0 and TopLeftX + Width and TopLeftY + Height must be <= D3D11_VIEWPORT_BOUNDS_MAX. Viewport Sizes and Feature Level Support Differences between Direct3D 11 and Direct3D 10: The range for the minimum and maximum viewport size is dependent on the feature level defined by . Direct3D 11 supports fractional viewports; the parameter types are floating-point numbers. The feature level, D3D_FEATURE_LEVEL_11_0, supports (D3D11_VIEWPORT_BOUNDS_MIN, D3D11_VIEWPORT_BOUNDS_MAX) values between (-32768, 32,767). Direct3D 10 does not support fractional viewports. The feature levels, D3D_FEATURE_LEVEL_10_1 (or below), supports (D3D10_VIEWPORT_BOUNDS_MIN, D3D10_VIEWPORT_BOUNDS_MAX) values between (-16384, 16383). ? + + D3D11_VIEWPORT + + + + X position of the left hand side of the viewport. Ranges between D3D11_VIEWPORT_BOUNDS_MIN and D3D11_VIEWPORT_BOUNDS_MAX. + + float TopLeftX + + + + Y position of the top of the viewport. Ranges between D3D11_VIEWPORT_BOUNDS_MIN and D3D11_VIEWPORT_BOUNDS_MAX. + + float TopLeftY + + + + Width of the viewport. + + float Width + + + + Height of the viewport. + + float Height + + + + Minimum depth of the viewport. Ranges between 0 and 1. + + float MinDepth + + + + Maximum depth of the viewport. Ranges between 0 and 1. + + float MaxDepth + + + + Initializes a new instance of the structure. + + The X coordinate of the viewport. + The Y coordinate of the viewport. + The width of the viewport. + The height of the viewport. + The minimum Z distance of the viewport. + The maximum Z distance of the viewport. + + + + Initializes a new instance of the structure. + + The X coordinate of the viewport. + The Y coordinate of the viewport. + The width of the viewport. + The height of the viewport. + + + + Defines a 3D box. + + + The following diagram shows a 3D box, where the origin is the left, front, top corner. ? Diagram of a 3D box, where the origin is the left, front, top corner ? + + D3D11_BOX + + + + The x position of the left hand side of the box. + + int left + + + + The y position of the top of the box. + + int top + + + + The z position of the front of the box. + + int front + + + + The x position of the right hand side of the box. + + int right + + + + The y position of the bottom of the box. + + int bottom + + + + The z position of the back of the box. + + int back + + + + Stencil operations that can be performed based on the results of stencil test. + + + All stencil operations are specified as a . The stencil operation can be set differently based on the outcome of the stencil test (which is referred to as StencilFunc in the stencil test portion of depth-stencil testing. This structure is a member of a {{depth-stencil description}}. + + D3D11_DEPTH_STENCILOP_DESC + + + + The stencil operation to perform when stencil testing fails. + + D3D11_STENCIL_OP StencilFailOp + + + + The stencil operation to perform when stencil testing passes and depth testing fails. + + D3D11_STENCIL_OP StencilDepthFailOp + + + + The stencil operation to perform when stencil testing and depth testing both pass. + + D3D11_STENCIL_OP StencilPassOp + + + + A function that compares stencil data against existing stencil data. The function options are listed in . + + D3D11_COMPARISON_FUNC StencilFunc + + + + Describes depth-stencil state. + + + Depth-stencil state controls how depth-stencil testing is performed by the output-merger stage. The following table shows the default values of depth-stencil states. StateDefault Value DepthEnableTRUE DepthWriteMaskD3D11_DEPTH_WRITE_MASK_ALL DepthFuncD3D11_COMPARISON_LESS StencilEnableFALSE StencilReadMaskD3D11_DEFAULT_STENCIL_READ_MASK StencilWriteMaskD3D11_DEFAULT_STENCIL_WRITE_MASK StencilFuncD3D11_COMPARISON_ALWAYS StencilDepthFailOpD3D11_STENCIL_OP_KEEP StencilPassOpD3D11_STENCIL_OP_KEEP StencilFailOpD3D11_STENCIL_OP_KEEP ? The formats that support stenciling are DXGI_FORMAT_D24_UNORM_S8_UINT and DXGI_FORMAT_D32_FLOAT_S8X24_UINT. + + D3D11_DEPTH_STENCIL_DESC + + + + Identify a portion of the depth-stencil buffer that can be modified by depth data (see ). + + D3D11_DEPTH_WRITE_MASK DepthWriteMask + + + + A function that compares depth data against existing depth data. The function options are listed in . + + D3D11_COMPARISON_FUNC DepthFunc + + + + Identify a portion of the depth-stencil buffer for reading stencil data. + + byte StencilReadMask + + + + Identify a portion of the depth-stencil buffer for writing stencil data. + + byte StencilWriteMask + + + + Identify how to use the results of the depth test and the stencil test for pixels whose surface normal is facing towards the camera (see ). + + D3D11_DEPTH_STENCILOP_DESC FrontFace + + + + Identify how to use the results of the depth test and the stencil test for pixels whose surface normal is facing away from the camera (see ). + + D3D11_DEPTH_STENCILOP_DESC BackFace + + + + Enable depth testing. + + BOOL DepthEnable + + + + Enable stencil testing. + + BOOL StencilEnable + + + + Describes the blend state for a render target. + + + To see how blending is done, see the output-merger stage. These are the default values for blend state. StateDefault Value BlendEnableFALSE SrcBlendD3D11_BLEND_ONE DestBlendD3D11_BLEND_ZERO BlendOpD3D11_BLEND_OP_ADD SrcBlendAlphaD3D11_BLEND_ONE DestBlendAlphaD3D11_BLEND_ZERO BlendOpAlphaD3D11_BLEND_OP_ADD RenderTargetWriteMaskD3D11_COLOR_WRITE_ENABLE_ALL ? + + D3D11_RENDER_TARGET_BLEND_DESC + + + + This {{blend option}} specifies the first RGB data source and includes an optional pre-blend operation. + + D3D11_BLEND SrcBlend + + + + This {{blend option}} specifies the second RGB data source and includes an optional pre-blend operation. + + D3D11_BLEND DestBlend + + + + This {{blend operation}} defines how to combine the RGB data sources. + + D3D11_BLEND_OP BlendOp + + + + This {{blend option}} specifies the first alpha data source and includes an optional pre-blend operation. Blend options that end in _COLOR are not allowed. + + D3D11_BLEND SrcBlendAlpha + + + + This {{blend option}} specifies the second alpha data source and includes an optional pre-blend operation. Blend options that end in _COLOR are not allowed. + + D3D11_BLEND DestBlendAlpha + + + + This {{blend operation}} defines how to combine the alpha data sources. + + D3D11_BLEND_OP BlendOpAlpha + + + + A write mask. + + D3D11_COLOR_WRITE_ENABLE RenderTargetWriteMask + + + + Enable (or disable) blending. + + BOOL BlendEnable + + + + Describes the blend state. + + + These are the default values for blend state. StateDefault Value AlphaToCoverageEnableFALSE IndependentBlendEnableFALSE RenderTarget[0].BlendEnableFALSE RenderTarget[0].SrcBlendD3D11_BLEND_ONE RenderTarget[0].DestBlendD3D11_BLEND_ZERO RenderTarget[0].BlendOpD3D11_BLEND_OP_ADD RenderTarget[0].SrcBlendAlphaD3D11_BLEND_ONE RenderTarget[0].DestBlendAlphaD3D11_BLEND_ZERO RenderTarget[0].BlendOpAlphaD3D11_BLEND_OP_ADD RenderTarget[0].RenderTargetWriteMaskD3D11_COLOR_WRITE_ENABLE_ALL ? Note that D3D11_BLEND_DESC is identical to . If the driver type is set to , the feature level is set to less than or equal to , and the pixel format of the render target is set to , DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, or DXGI_FORMAT_B8G8R8X8_UNORM_SRGB, the display device performs the blend in standard RGB (sRGB) space and not in linear space. However, if the feature level is set to greater than D3D_FEATURE_LEVEL_9_3, the display device performs the blend in linear space. + + D3D11_BLEND_DESC + + + + Determines whether or not to use alpha-to-coverage as a multisampling technique when setting a pixel to a rendertarget. + + BOOL AlphaToCoverageEnable + + + + Set to TRUE to enable independent blending in simultaneous render targets. If set to FALSE, only the RenderTarget[0] members are used. RenderTarget[1..7] are ignored. + + BOOL IndependentBlendEnable + + + + An array of render-target-blend descriptions (see ); these correspond to the eight rendertargets that can be set to the output-merger stage at one time. + + D3D11_RENDER_TARGET_BLEND_DESC RenderTarget[8] + + + + Describes rasterizer state. + + + Rasterizer state defines the behavior of the rasterizer stage; to set rasterizer state, call . These are the default values for rasterizer state. StateDefault Value FillModeSolid CullModeBack FrontCounterClockwiseFALSE DepthBias0 SlopeScaledDepthBias0.0f DepthBiasClamp0.0f DepthClipEnableTRUE ScissorEnableFALSE MultisampleEnableFALSE AntialiasedLineEnableFALSE ? + + D3D11_RASTERIZER_DESC + + + + Determines the fill mode to use when rendering (see ). + + D3D11_FILL_MODE FillMode + + + + Indicates triangles facing the specified direction are not drawn (see ). + + D3D11_CULL_MODE CullMode + + + + Depth value added to a given pixel. + + int DepthBias + + + + Maximum depth bias of a pixel. + + float DepthBiasClamp + + + + Scalar on a given pixel's slope. + + float SlopeScaledDepthBias + + + + Determines if a triangle is front- or back-facing. If this parameter is true, then a triangle will be considered front-facing if its vertices are counter-clockwise on the render target and considered back-facing if they are clockwise. If this parameter is false then the opposite is true. + + BOOL FrontCounterClockwise + + + + Enable clipping based on distance. + + BOOL DepthClipEnable + + + + Enable scissor-rectangle culling. All pixels ouside an active scissor rectangle are culled. + + BOOL ScissorEnable + + + + Enable multisample antialiasing. + + BOOL MultisampleEnable + + + + Enable line antialiasing; only applies if doing line drawing and MultisampleEnable is false. + + BOOL AntialiasedLineEnable + + + + Specifies data for initializing a subresource. + + + This structure is used in calls to create buffers () and textures (, , and ). If the resource being created does not require a system-memory pitch or a system-memory-pitch slice, then you are free to use those members to pass size information which may help you when debugging a problem creating a resource. Note that an application should not rely on SysMemPitch being exactly equal to the number of texels in a line times the size of a texel. In some cases SysMemPitch will include padding to skip past additional data in a line. This could be padding for alignment or the texture could be a subsection of a larger texture. For example the D3D11_SUBRESOURCE_DATA structure could represent a 32 by 32 subsection of a 128 by 128 texture. The value for SysMemSlicePitch will reflect any padding included in SysMemPitch. + + D3D11_SUBRESOURCE_DATA + + + + Pointer to the initialization data. + + const void* pSysMem + + + + The distance (in bytes) from the beginning of one line of a texture to the next line. System-memory pitch is used only for 2D and 3D texture data as it is has no meaning for the other resource types. + + int SysMemPitch + + + + The distance (in bytes) from the beginning of one depth level to the next. System-memory-slice pitch is only used for 3D texture data as it has no meaning for the other resource types. + + int SysMemSlicePitch + + + + Provides access to subresource data. + + + This structure is used in a call to . + + D3D11_MAPPED_SUBRESOURCE + + + + Pointer to the data. When provides the reference, the runtime ensures that the reference has a specific alignment, depending on the following feature levels: For and higher, the reference is aligned to 16 bytes. For lower than , the reference is aligned to 4 bytes. + + void* pData + + + + The row pitch, or width, or physical size (in bytes) of the data. + + int RowPitch + + + + The depth pitch, or width, or physical size (in bytes)of the data. + + int DepthPitch + + + + Describes a 1D texture. + + + This structure is used in a call to . A helpful derived structure CD3D11_TEXTURE1D_DESC is declared in D3D11.h, to help create a texture description. + + D3D11_TEXTURE1D_DESC + + + + Texture width (in texels). The range is from 1 to D3D11_REQ_TEXTURE1D_U_DIMENSION (16384). + + int Width + + + + The maximum number of mipmap levels in the texture. See the remarks in . Use 1 for a multisampled texture; or 0 to generate a full set of subtextures. + + int MipLevels + + + + Number of textures in the array. The range is from 1 to D3D11_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION (2048). + + int ArraySize + + + + Texture format (see ). + + DXGI_FORMAT Format + + + + Value that identifies how the texture is to be read from and written to. The most common value is D3D11_USAGE-DEFAULT; see for all possible values. + + D3D11_USAGE Usage + + + + Flags (see ) for binding to pipeline stages. The flags can be combined by a logical OR. For a 1D texture, the allowable values are: D3D11_BIND_SHADER_RESOURCE, D3D11_BIND_RENDER_TARGET and D3D11_BIND_DEPTH_STENCIL. + + D3D11_BIND_FLAG BindFlags + + + + Flags (see ) to specify the types of CPU access allowed. Use 0 if CPU access is not required. These flags can be combined with a logical OR. + + D3D11_CPU_ACCESS_FLAG CPUAccessFlags + + + + Flags (see ) that identify other, less common resource options. Use 0 if none of these flags apply. These flags can be combined with a logical OR. + + D3D11_RESOURCE_MISC_FLAG MiscFlags + + + + Describes a 2D texture. + + + This structure is used in a call to . A helpful derived structure CD3D11_TEXTURE2D_DESC is declared in D3D11.h, to help create a texture description. The device places some size restrictions (must be multiples of a minimum size) for a subsampled, block compressed, or bit-format resource. + + D3D11_TEXTURE2D_DESC + + + + Texture width (in texels). The range is from 1 to D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION (16384). For a texture cube-map, the range is from 1 to D3D11_REQ_TEXTURECUBE_DIMENSION (16384). For more information about restrictions, see Remarks. + + int Width + + + + Texture height (in texels). The range is from 1 to D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION (16384). For a texture cube-map, the range is from 1 to D3D11_REQ_TEXTURECUBE_DIMENSION (16384). For more information about restrictions, see Remarks. + + int Height + + + + The maximum number of mipmap levels in the texture. See the remarks in . Use 1 for a multisampled texture; or 0 to generate a full set of subtextures. + + int MipLevels + + + + Number of textures in the texture array. The range is from 1 to D3D11_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION (2048). For a texture cube-map, this value is a multiple of 6 (that is, 6 times the value in the NumCubes member of ), and the range is from 6 to D3D11_REQ_TEXTURECUBE_DIMENSION. + + int ArraySize + + + + Texture format (see ). + + DXGI_FORMAT Format + + + + Structure that specifies multisampling parameters for the texture. See . + + DXGI_SAMPLE_DESC SampleDesc + + + + Value that identifies how the texture is to be read from and written to. The most common value is D3D11_USAGE-DEFAULT; see for all possible values. + + D3D11_USAGE Usage + + + + Flags (see ) for binding to pipeline stages. The flags can be combined by a logical OR. + + D3D11_BIND_FLAG BindFlags + + + + Flags (see ) to specify the types of CPU access allowed. Use 0 if CPU access is not required. These flags can be combined with a logical OR. + + D3D11_CPU_ACCESS_FLAG CPUAccessFlags + + + + Flags (see ) that identify other, less common resource options. Use 0 if none of these flags apply. These flags can be combined by using a logical OR. For a texture cube-map, set the flag. Cube-map arrays (that is, ArraySize > 6) require feature level or higher. + + D3D11_RESOURCE_MISC_FLAG MiscFlags + + + + Describes a 3D texture. + + + This structure is used in a call to . A helpful derived structure CD3D11_TEXTURE3D_DESC is declared in D3D11.h, to help create a texture description. The device restricts the size of subsampled, block compressed, and bit format resources to be multiples of sizes specific to each format. + + D3D11_TEXTURE3D_DESC + + + + Texture width (in texels). The range is from 1 to D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION (2048). For more information about restrictions, see Remarks. + + int Width + + + + Texture height (in texels). The range is from 1 to D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION (2048). For more information about restrictions, see Remarks. + + int Height + + + + Texture depth (in texels). The range is from 1 to D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION (2048). + + int Depth + + + + The maximum number of mipmap levels in the texture. See the remarks in . Use 1 for a multisampled texture; or 0 to generate a full set of subtextures. + + int MipLevels + + + + Texture format (see ). + + DXGI_FORMAT Format + + + + Value that identifies how the texture is to be read from and written to. The most common value is D3D11_USAGE-DEFAULT; see for all possible values. + + D3D11_USAGE Usage + + + + Flags (see ) for binding to pipeline stages. The flags can be combined by a logical OR. + + D3D11_BIND_FLAG BindFlags + + + + Flags (see ) to specify the types of CPU access allowed. Use 0 if CPU access is not required. These flags can be combined with a logical OR. + + D3D11_CPU_ACCESS_FLAG CPUAccessFlags + + + + Flags (see ) that identify other, less common resource options. Use 0 if none of these flags apply. These flags can be combined with a logical OR. + + D3D11_RESOURCE_MISC_FLAG MiscFlags + + + + Describes a shader-resource view. + + + A view is a format-specific way to look at the data in a resource. The view determines what data to look at, and how it is cast when read. When viewing a resource, the resource-view description must specify a typed format, that is compatible with the resource format. So that means that you cannot create a resource-view description using any format with _TYPELESS in the name. You can however view a typeless resource by specifying a typed format for the view. For example, a DXGI_FORMAT_R32G32B32_TYPELESS resource can be viewed with one of these typed formats: DXGI_FORMAT_R32G32B32_FLOAT, DXGI_FORMAT_R32G32B32_UINT, and DXGI_FORMAT_R32G32B32_SINT, since these typed formats are compatible with the typeless resource. Create a shader-resource-view description by calling . To view a shader-resource-view description, call . + + D3D11_SHADER_RESOURCE_VIEW_DESC + + + + A specifying the viewing format. See remarks. + + DXGI_FORMAT Format + + + + The resource type of the view. See . This should be the same as the resource type of the underlying resource. This parameter also determines which _SRV to use in the union below. + + D3D11_SRV_DIMENSION ViewDimension + + + + View the resource as a buffer using information from a shader-resource view (see ). + + D3D11_BUFFER_SRV Buffer + + + + View the resource as a 1D texture using information from a shader-resource view (see ). + + D3D11_TEX1D_SRV Texture1D + + + + View the resource as a 1D-texture array using information from a shader-resource view (see ). + + D3D11_TEX1D_ARRAY_SRV Texture1DArray + + + + View the resource as a 2D-texture using information from a shader-resource view (see ). + + D3D11_TEX2D_SRV Texture2D + + + + View the resource as a 2D-texture array using information from a shader-resource view (see ). + + D3D11_TEX2D_ARRAY_SRV Texture2DArray + + + + View the resource as a 2D-multisampled texture using information from a shader-resource view (see ). + + D3D11_TEX2DMS_SRV Texture2DMS + + + + View the resource as a 2D-multisampled-texture array using information from a shader-resource view (see ). + + D3D11_TEX2DMS_ARRAY_SRV Texture2DMSArray + + + + View the resource as a 3D texture using information from a shader-resource view (see ). + + D3D11_TEX3D_SRV Texture3D + + + + View the resource as a 3D-cube texture using information from a shader-resource view (see ). + + D3D11_TEXCUBE_SRV TextureCube + + + + View the resource as a 3D-cube-texture array using information from a shader-resource view (see ). + + D3D11_TEXCUBE_ARRAY_SRV TextureCubeArray + + + + View the resource as an extended buffer using information from a shader-resource view (see ). + + D3D11_BUFFEREX_SRV BufferEx + + + + Specifies the elements in a buffer resource to use in a shader-resource view. + + + The D3D11_BUFFER_SRV structure is a member of the structure, which represents a shader-resource view description. You can create a shader-resource view by calling the method. + + D3D11_BUFFER_SRV + + + + The offset of the first element in the view to access, relative to element 0. + + int FirstElement + + + + The total number of elements in the view. + + int ElementOffset + + + + No documentation. + + int NumElements + + + + No documentation. + + int ElementWidth + + + + Describes a raw buffer resource. + + + This structure is used by to create a raw buffer. + + D3D11_BUFFEREX_SRV + + + + The index of the first element to be accessed by the view. + + int FirstElement + + + + The number of elements in the resource. + + int NumElements + + + + Options for binding a raw buffer (see ). + + D3D11_BUFFEREX_SRV_FLAG Flags + + + + Specifies the subresource from a 1D texture to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). As an example, assuming MostDetailedMip = 6 and MipLevels = 2, the view will have access to 2 mipmap levels, 6 and 7, of the original texture for which creates the view. In this situation, MostDetailedMip is greater than the MipLevels in the view. However, MostDetailedMip is not greater than the MipLevels in the original resource. + + D3D11_TEX1D_SRV + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture1D for which creates a view) -1. + + int MostDetailedMip + + + + The maximum number of mipmap levels for the view of the texture. See the remarks. Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. + + int MipLevels + + + + Specifies the subresources from an array of 1D textures to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). + + D3D11_TEX1D_ARRAY_SRV + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture1D for which creates a view) -1. + + int MostDetailedMip + + + + The maximum number of mipmap levels for the view of the texture. See the remarks in . Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. + + int MipLevels + + + + The index of the first texture to use in an array of textures. + + int FirstArraySlice + + + + Number of textures in the array. + + int ArraySize + + + + Specifies the subresource from a 2D texture to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). + + D3D11_TEX2D_SRV + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture2D for which creates a view) -1. + + int MostDetailedMip + + + + The maximum number of mipmap levels for the view of the texture. See the remarks in . Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. + + int MipLevels + + + + Specifies the subresources from an array of 2D textures to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). + + D3D11_TEX2D_ARRAY_SRV + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture2D for which creates a view) -1. + + int MostDetailedMip + + + + The maximum number of mipmap levels for the view of the texture. See the remarks in . Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. + + int MipLevels + + + + The index of the first texture to use in an array of textures. + + int FirstArraySlice + + + + Number of textures in the array. + + int ArraySize + + + + Specifies the subresources from a 3D texture to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). + + D3D11_TEX3D_SRV + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original Texture3D for which creates a view) -1. + + int MostDetailedMip + + + + The maximum number of mipmap levels for the view of the texture. See the remarks in . Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. + + int MipLevels + + + + Specifies the subresource from a cube texture to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). + + D3D11_TEXCUBE_SRV + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original TextureCube for which creates a view) -1. + + int MostDetailedMip + + + + The maximum number of mipmap levels for the view of the texture. See the remarks in . Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. + + int MipLevels + + + + Specifies the subresources from an array of cube textures to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). + + D3D11_TEXCUBE_ARRAY_SRV + + + + Index of the most detailed mipmap level to use; this number is between 0 and MipLevels (from the original TextureCube for which creates a view) -1. + + int MostDetailedMip + + + + The maximum number of mipmap levels for the view of the texture. See the remarks in . Set to -1 to indicate all the mipmap levels from MostDetailedMip on down to least detailed. + + int MipLevels + + + + Index of the first 2D texture to use. + + int First2DArrayFace + + + + Number of cube textures in the array. + + int NumCubes + + + + Specifies the subresources from a multisampled 2D texture to use in a shader-resource view. + + + Since a multisampled 2D texture contains a single subresource, there is actually nothing to specify in D3D11_TEX2DMS_RTV. Consequently, UnusedField_NothingToDefine is included so that this structure will compile in C. + + D3D11_TEX2DMS_SRV + + + + Integer of any value. See remarks. + + int UnusedField_NothingToDefine + + + + Specifies the subresources from an array of multisampled 2D textures to use in a shader-resource view. + + + This structure is one member of a shader-resource-view description (see ). + + D3D11_TEX2DMS_ARRAY_SRV + + + + The index of the first texture to use in an array of textures. + + int FirstArraySlice + + + + Number of textures to use. + + int ArraySize + + + + Specifies the subresources from a resource that are accessible using a render-target view. + + + A render-target-view description is passed into to create a render target. A render-target-view cannot use the following formats: Any typeless format. DXGI_FORMAT_R32G32B32 if the view will be used to bind a buffer (vertex, index, constant, or stream-output). If the format is set to DXGI_FORMAT_UNKNOWN, then the format of the resource that the view binds to the pipeline will be used. + + D3D11_RENDER_TARGET_VIEW_DESC + + + + The data format (see ). + + DXGI_FORMAT Format + + + + The resource type (see ), which specifies how the render-target resource will be accessed. + + D3D11_RTV_DIMENSION ViewDimension + + + + Specifies which buffer elements can be accessed (see ). + + D3D11_BUFFER_RTV Buffer + + + + Specifies the subresources in a 1D texture that can be accessed (see ). + + D3D11_TEX1D_RTV Texture1D + + + + Specifies the subresources in a 1D texture array that can be accessed (see ). + + D3D11_TEX1D_ARRAY_RTV Texture1DArray + + + + Specifies the subresources in a 2D texture that can be accessed (see ). + + D3D11_TEX2D_RTV Texture2D + + + + Specifies the subresources in a 2D texture array that can be accessed (see ). + + D3D11_TEX2D_ARRAY_RTV Texture2DArray + + + + Specifies a single subresource because a multisampled 2D texture only contains one subresource (see ). + + D3D11_TEX2DMS_RTV Texture2DMS + + + + Specifies the subresources in a multisampled 2D texture array that can be accessed (see ). + + D3D11_TEX2DMS_ARRAY_RTV Texture2DMSArray + + + + Specifies subresources in a 3D texture that can be accessed (see ). + + D3D11_TEX3D_RTV Texture3D + + + + Specifies the elements in a buffer resource to use in a render-target view. + + + A render-target view is a member of a render-target-view description (see ). Create a render-target view by calling . + + D3D11_BUFFER_RTV + + + + Number of bytes between the beginning of the buffer and the first element to access. + + int FirstElement + + + + The width of each element (in bytes). This can be determined from the format stored in the render-target-view description. + + int ElementOffset + + + + No documentation. + + int NumElements + + + + No documentation. + + int ElementWidth + + + + Specifies the subresource from a 1D texture to use in a render-target view. + + + This structure is one member of a render-target-view description (see ). + + D3D11_TEX1D_RTV + + + + The index of the mipmap level to use mip slice. + + int MipSlice + + + + Specifies the subresources from an array of 1D textures to use in a render-target view. + + + This structure is one member of a render-target-view description (see ). + + D3D11_TEX1D_ARRAY_RTV + + + + The index of the mipmap level to use mip slice. + + int MipSlice + + + + The index of the first texture to use in an array of textures. + + int FirstArraySlice + + + + Number of textures to use. + + int ArraySize + + + + Specifies the subresource from a 2D texture to use in a render-target view. + + + This structure is one member of a render-target-view description (see ). + + D3D11_TEX2D_RTV + + + + The index of the mipmap level to use mip slice. + + int MipSlice + + + + Specifies the subresource from a multisampled 2D texture to use in a render-target view. + + + Since a multisampled 2D texture contains a single subresource, there is actually nothing to specify in D3D11_TEX2DMS_RTV. Consequently, UnusedField_NothingToDefine is included so that this structure will compile in C. + + D3D11_TEX2DMS_RTV + + + + Integer of any value. See remarks. + + int UnusedField_NothingToDefine + + + + Specifies the subresources from an array of 2D textures to use in a render-target view. + + + This structure is one member of a render-target-view description (see ). + + D3D11_TEX2D_ARRAY_RTV + + + + The index of the mipmap level to use mip slice. + + int MipSlice + + + + The index of the first texture to use in an array of textures. + + int FirstArraySlice + + + + Number of textures in the array to use in the render target view, starting from FirstArraySlice. + + int ArraySize + + + + Specifies the subresources from a an array of multisampled 2D textures to use in a render-target view. + + + This structure is one member of a render-target-view description (see ). + + D3D11_TEX2DMS_ARRAY_RTV + + + + The index of the first texture to use in an array of textures. + + int FirstArraySlice + + + + Number of textures to use. + + int ArraySize + + + + Specifies the subresources from a 3D texture to use in a render-target view. + + + This structure is one member of a render target view. See . + + D3D11_TEX3D_RTV + + + + The index of the mipmap level to use mip slice. + + int MipSlice + + + + First depth level to use. + + int FirstWSlice + + + + Number of depth levels to use in the render-target view, starting from FirstWSlice. A value of -1 indicates all of the slices along the w axis, starting from FirstWSlice. + + int WSize + + + + Specifies the subresources of a texture that are accessible from a depth-stencil view. + + + These are valid formats for a depth-stencil view: DXGI_FORMAT_D16_UNORM DXGI_FORMAT_D24_UNORM_S8_UINT DXGI_FORMAT_D32_FLOAT DXGI_FORMAT_D32_FLOAT_S8X24_UINT DXGI_FORMAT_UNKNOWN A depth-stencil view cannot use a typeless format. If the format chosen is DXGI_FORMAT_UNKNOWN, then the format of the parent resource is used. A depth-stencil-view description is needed when calling . + + D3D11_DEPTH_STENCIL_VIEW_DESC + + + + Resource data format (see ). See remarks for allowable formats. + + DXGI_FORMAT Format + + + + Type of resource (see ). Specifies how a depth-stencil resource will be accessed; the value is stored in the union in this structure. + + D3D11_DSV_DIMENSION ViewDimension + + + + A value that describes whether the texture is read only. Pass 0 to specify that it is not read only; otherwise, pass one of the members of the enumerated type. + + D3D11_DSV_FLAG Flags + + + + Specifies a 1D texture subresource (see ). + + D3D11_TEX1D_DSV Texture1D + + + + Specifies an array of 1D texture subresources (see ). + + D3D11_TEX1D_ARRAY_DSV Texture1DArray + + + + Specifies a 2D texture subresource (see ). + + D3D11_TEX2D_DSV Texture2D + + + + Specifies an array of 2D texture subresources (see ). + + D3D11_TEX2D_ARRAY_DSV Texture2DArray + + + + Specifies a multisampled 2D texture (see ). + + D3D11_TEX2DMS_DSV Texture2DMS + + + + Specifies an array of multisampled 2D textures (see ). + + D3D11_TEX2DMS_ARRAY_DSV Texture2DMSArray + + + + Specifies the subresource from a 1D texture that is accessible to a depth-stencil view. + + + This structure is one member of a depth-stencil-view description (see ). + + D3D11_TEX1D_DSV + + + + The index of the first mipmap level to use. + + int MipSlice + + + + Specifies the subresources from an array of 1D textures to use in a depth-stencil view. + + + This structure is one member of a depth-stencil-view description (see ). + + D3D11_TEX1D_ARRAY_DSV + + + + The index of the first mipmap level to use. + + int MipSlice + + + + The index of the first texture to use in an array of textures. + + int FirstArraySlice + + + + Number of textures to use. + + int ArraySize + + + + Specifies the subresource from a 2D texture that is accessible to a depth-stencil view. + + + This structure is one member of a depth-stencil-view description (see ). + + D3D11_TEX2D_DSV + + + + The index of the first mipmap level to use. + + int MipSlice + + + + Specifies the subresources from an array 2D textures that are accessible to a depth-stencil view. + + + This structure is one member of a depth-stencil-view description (see ). + + D3D11_TEX2D_ARRAY_DSV + + + + The index of the first mipmap level to use. + + int MipSlice + + + + The index of the first texture to use in an array of textures. + + int FirstArraySlice + + + + Number of textures to use. + + int ArraySize + + + + Specifies the subresource from a multisampled 2D texture that is accessible to a depth-stencil view. + + + Because a multisampled 2D texture contains a single subtexture, there is nothing to specify; this unused member is included so that this structure will compile in C. + + D3D11_TEX2DMS_DSV + + + + Unused. + + int UnusedField_NothingToDefine + + + + Specifies the subresources from an array of multisampled 2D textures for a depth-stencil view. + + + This structure is one member of a depth-stencil-view description (see ). + + D3D11_TEX2DMS_ARRAY_DSV + + + + The index of the first texture to use in an array of textures. + + int FirstArraySlice + + + + Number of textures to use. + + int ArraySize + + + + Specifies the subresources from a resource that are accessible using an unordered-access view. + + + An unordered-access-view description is passed into to create a view. + + D3D11_UNORDERED_ACCESS_VIEW_DESC + + + + The data format (see ). + + DXGI_FORMAT Format + + + + The resource type (see ), which specifies how the resource will be accessed. + + D3D11_UAV_DIMENSION ViewDimension + + + + Specifies which buffer elements can be accessed (see ). + + D3D11_BUFFER_UAV Buffer + + + + Specifies the subresources in a 1D texture that can be accessed (see ). + + D3D11_TEX1D_UAV Texture1D + + + + Specifies the subresources in a 1D texture array that can be accessed (see ). + + D3D11_TEX1D_ARRAY_UAV Texture1DArray + + + + Specifies the subresources in a 2D texture that can be accessed (see ). + + D3D11_TEX2D_UAV Texture2D + + + + Specifies the subresources in a 2D texture array that can be accessed (see ). + + D3D11_TEX2D_ARRAY_UAV Texture2DArray + + + + Specifies subresources in a 3D texture that can be accessed (see ). + + D3D11_TEX3D_UAV Texture3D + + + + Describes a unordered-access buffer resource. + + + This structure is used by a . + + D3D11_BUFFER_UAV + + + + The zero-based index of the first element to be accessed. + + int FirstElement + + + + The number of elements in the resource. For structured buffers, this is the number of structures in the buffer. + + int NumElements + + + + View options for the resource (see ). + + D3D11_BUFFER_UAV_FLAG Flags + + + + Describes a unordered-access 1D texture resource. + + + This structure is used by a . + + D3D11_TEX1D_UAV + + + + The mipmap slice index. + + int MipSlice + + + + Describes an array of unordered-access 1D texture resources. + + + This structure is used by a . + + D3D11_TEX1D_ARRAY_UAV + + + + The mipmap slice index. + + int MipSlice + + + + The zero-based index of the first array slice to be accessed. + + int FirstArraySlice + + + + The number of slices in the array. + + int ArraySize + + + + Describes a unordered-access 2D texture resource. + + + This structure is used by a . + + D3D11_TEX2D_UAV + + + + The mipmap slice index. + + int MipSlice + + + + Describes an array of unordered-access 2D texture resources. + + + This structure is used by a . + + D3D11_TEX2D_ARRAY_UAV + + + + The mipmap slice index. + + int MipSlice + + + + The zero-based index of the first array slice to be accessed. + + int FirstArraySlice + + + + The number of slices in the array. + + int ArraySize + + + + Describes a unordered-access 3D texture resource. + + + This structure is used by a . + + D3D11_TEX3D_UAV + + + + The mipmap slice index. + + int MipSlice + + + + The zero-based index of the first depth slice to be accessed. + + int FirstWSlice + + + + The number of depth slices. + + int WSize + + + + Describes a sampler state. + + + These are the default values for sampler state. StateDefault Value FilterMIN_MAG_MIP_LINEAR AddressUClamp AddressVClamp AddressWClamp MinLOD-3.402823466e+38F (-FLT_MAX) MaxLOD3.402823466e+38F (FLT_MAX) MipMapLODBias0.0f MaxAnisotropy16 ComparisonFuncNever BorderColorfloat4(0.0f,0.0f,0.0f,0.0f) TextureN/A ? + + D3D11_SAMPLER_DESC + + + + Filtering method to use when sampling a texture (see ). + + D3D11_FILTER Filter + + + + Method to use for resolving a u texture coordinate that is outside the 0 to 1 range (see ). + + D3D11_TEXTURE_ADDRESS_MODE AddressU + + + + Method to use for resolving a v texture coordinate that is outside the 0 to 1 range. + + D3D11_TEXTURE_ADDRESS_MODE AddressV + + + + Method to use for resolving a w texture coordinate that is outside the 0 to 1 range. + + D3D11_TEXTURE_ADDRESS_MODE AddressW + + + + Offset from the calculated mipmap level. For example, if Direct3D calculates that a texture should be sampled at mipmap level 3 and MipLODBias is 2, then the texture will be sampled at mipmap level 5. + + float MipLODBias + + + + Clamping value used if D3D11_FILTER_ANISOTROPIC or D3D11_FILTER_COMPARISON_ANISOTROPIC is specified in Filter. Valid values are between 1 and 16. + + int MaxAnisotropy + + + + A function that compares sampled data against existing sampled data. The function options are listed in . + + D3D11_COMPARISON_FUNC ComparisonFunc + + + + Border color to use if D3D11_TEXTURE_ADDRESS_BORDER is specified for AddressU, AddressV, or AddressW. Range must be between 0.0 and 1.0 inclusive. + + SHARPDX_COLOR4 BorderColor + + + + Lower end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed. + + float MinLOD + + + + Upper end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed. This value must be greater than or equal to MinLOD. To have no upper limit on LOD set this to a large value such as D3D11_FLOAT32_MAX. + + float MaxLOD + + + + Describes a query. + + D3D11_QUERY_DESC + + + + Type of query (see ). + + D3D11_QUERY Query + + + + Miscellaneous flags (see ). + + D3D11_QUERY_MISC_FLAG MiscFlags + + + + Query information about the reliability of a timestamp query. + + + For a list of query types see . + + D3D11_QUERY_DATA_TIMESTAMP_DISJOINT + + + + How frequently the GPU counter increments in Hz. + + __int64 Frequency + + + + If this is TRUE, something occurred in between the query's and calls that caused the timestamp counter to become discontinuous or disjoint, such as unplugging the AC chord on a laptop, overheating, or throttling up/down due to laptop savings events. The timestamp returned by for a timestamp query is only reliable if Disjoint is FALSE. + + BOOL Disjoint + + + + Query information about graphics-pipeline activity in between calls to and . + + D3D11_QUERY_DATA_PIPELINE_STATISTICS + + + + Number of vertices read by input assembler. + + __int64 IAVertices + + + + Number of primitives read by the input assembler. This number can be different depending on the primitive topology used. For example, a triangle strip with 6 vertices will produce 4 triangles, however a triangle list with 6 vertices will produce 2 triangles. + + __int64 IAPrimitives + + + + Number of times a vertex shader was invoked. Direct3D invokes the vertex shader once per vertex. + + __int64 VSInvocations + + + + Number of times a geometry shader was invoked. When the geometry shader is set to NULL, this statistic may or may not increment depending on the hardware manufacturer. + + __int64 GSInvocations + + + + Number of primitives output by a geometry shader. + + __int64 GSPrimitives + + + + Number of primitives that were sent to the rasterizer. When the rasterizer is disabled, this will not increment. + + __int64 CInvocations + + + + Number of primitives that were rendered. This may be larger or smaller than CInvocations because after a primitive is clipped sometimes it is either broken up into more than one primitive or completely culled. + + __int64 CPrimitives + + + + Number of times a pixel shader was invoked. + + __int64 PSInvocations + + + + Number of times a hull shader was invoked. + + __int64 HSInvocations + + + + Number of times a domain shader was invoked. + + __int64 DSInvocations + + + + Number of times a compute shader was invoked. + + __int64 CSInvocations + + + + Query information about the amount of data streamed out to the stream-output buffers in between and . + + D3D11_QUERY_DATA_SO_STATISTICS + + + + Number of primitives (that is, points, lines, and triangles) written to the stream-output buffers. + + __int64 NumPrimitivesWritten + + + + Number of primitives that would have been written to the stream-output buffers if there had been enough space for them all. + + __int64 PrimitivesStorageNeeded + + + + Describes a counter. + + + This structure is used by , and . + + D3D11_COUNTER_DESC + + + + Type of counter (see ). + + D3D11_COUNTER Counter + + + + Reserved. + + int MiscFlags + + + + Information about the video card's performance counter capabilities. + + + This structure is returned by . + + D3D11_COUNTER_INFO + + + + Largest device-dependent counter ID that the device supports. If none are supported, this value will be 0. Otherwise it will be greater than or equal to D3D11_COUNTER_DEVICE_DEPENDENT_0. See . + + D3D11_COUNTER LastDeviceDependentCounter + + + + Number of counters that can be simultaneously supported. + + int NumSimultaneousCounters + + + + Number of detectable parallel units that the counter is able to discern. Values are 1 ~ 4. Use NumDetectableParallelUnits to interpret the values of the VERTEX_PROCESSING, GEOMETRY_PROCESSING, PIXEL_PROCESSING, and OTHER_GPU_PROCESSING counters. + + byte NumDetectableParallelUnits + + + + Describes an HLSL class instance. + + + The D3D11_CLASS_INSTANCE_DESC structure is returned by the method. The members of this structure except InstanceIndex are valid (non default values) if they describe a class instance aquired using . The InstanceIndex member is only valid when the class instance is aquired using . + + D3D11_CLASS_INSTANCE_DESC + + + + The instance ID of an HLSL class; the default value is 0. + + int InstanceId + + + + The instance index of an HLSL class; the default value is 0. + + int InstanceIndex + + + + The type ID of an HLSL class; the default value is 0. + + int TypeId + + + + Describes the constant buffer associated with an HLSL class; the default value is 0. + + int ConstantBuffer + + + + The base constant buffer offset associated with an HLSL class; the default value is 0. + + int BaseConstantBufferOffset + + + + The base texture associated with an HLSL class; the default value is 127. + + int BaseTexture + + + + The base sampler associated with an HLSL class; the default value is 15. + + int BaseSampler + + + + True if the class was created; the default value is false. + + BOOL Created + + + + Describes the multi-threading features that are supported by the current graphics driver. + + + Use the D3D11_FEATURE_DATA_THREADING structure with the method to determine multi-threading support. + + D3D11_FEATURE_DATA_THREADING + + + + TRUE means resources can be created concurrently on multiple threads while drawing; FALSE means that the presence of coarse synchronization will prevent concurrency. + + BOOL DriverConcurrentCreates + + + + TRUE means command lists are supported by the current driver; FALSE means that the API will emulate deferred contexts and command lists with software. + + BOOL DriverCommandLists + + + + Describes double data type support in the current graphics driver. + + D3D11_FEATURE_DATA_DOUBLES + + + + If TRUE doubles are allowed; otherwise FALSE. + + BOOL DoublePrecisionFloatShaderOps + + + + Describes which resources are supported by the current graphics driver for a given format. + + D3D11_FEATURE_DATA_FORMAT_SUPPORT + + + + to return information on. + + DXGI_FORMAT InFormat + + + + Combination of flags indicating which resources are supported. + + D3D11_FORMAT_SUPPORT OutFormatSupport + + + + Describes which unordered resource options are supported by the current graphics driver for a given format. + + D3D11_FEATURE_DATA_FORMAT_SUPPORT2 + + + + to return information on. + + DXGI_FORMAT InFormat + + + + Combination of flags indicating which unordered resource options are supported. + + D3D11_FORMAT_SUPPORT2 OutFormatSupport2 + + + + Describes compute shader and raw and structured buffer support in the current graphics driver. + + + Direct3D 11 devices (D3D_FEATURE_LEVEL_11_0) are required to support Compute Shader model 5.0. Direct3D 10.x devices (D3D_FEATURE_LEVEL_10_0, D3D_FEATURE_LEVEL_10_1) can optionally support Compute Shader model 4.0 or 4.1. + + D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS + + + + TRUE if compute shaders and raw and structured buffers are supported; otherwise FALSE. + + BOOL ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x + + + + A debug message in the Information Queue. + + + This structure is returned from as part of the Information Queue feature (see ). + + D3D11_MESSAGE + + + + The category of the message. See . + + D3D11_MESSAGE_CATEGORY Category + + + + The severity of the message. See . + + D3D11_MESSAGE_SEVERITY Severity + + + + The ID of the message. See . + + D3D11_MESSAGE_ID ID + + + + The message string. + + const char* pDescription + + + + The length of pDescription in bytes. + + SIZE_T DescriptionByteLength + + + + Allow or deny certain types of messages to pass through a filter. + + D3D11_INFO_QUEUE_FILTER_DESC + + + + Number of message categories to allow or deny. + + int NumCategories + + + + Array of message categories to allow or deny. Array must have at least NumCategories members (see ). + + D3D11_MESSAGE_CATEGORY* pCategoryList + + + + Number of message severity levels to allow or deny. + + int NumSeverities + + + + Array of message severity levels to allow or deny. Array must have at least NumSeverities members (see ). + + D3D11_MESSAGE_SEVERITY* pSeverityList + + + + Number of message IDs to allow or deny. + + int NumIDs + + + + Array of message IDs to allow or deny. Array must have at least NumIDs members (see ). + + D3D11_MESSAGE_ID* pIDList + + + + Debug message filter; contains a lists of message types to allow or deny. + + + For use with an . + + D3D11_INFO_QUEUE_FILTER + + + + Types of messages that you want to allow. See . + + D3D11_INFO_QUEUE_FILTER_DESC AllowList + + + + Types of messages that you want to deny. + + D3D11_INFO_QUEUE_FILTER_DESC DenyList + + + + Optionally provide information to texture loader APIs to control how textures get loaded. A value of D3DX11_DEFAULT for any of these parameters will cause D3DX to automatically pick use the value from the source file. + + + This structure is used by methods such as: {{D3DX11GetImageInfoFromFile}}, , or {{D3DX11GetImageInfoFromResource}}. + + D3DX11_IMAGE_INFO + + + + The target width of the texture. If the actual width of the texture is larger or smaller than this value then the texture will be scaled up or down to fit this target width. + + int Width + + + + The target height of the texture. If the actual height of the texture is larger or smaller than this value then the texture will be scaled up or down to fit this target height. + + int Height + + + + The depth of the texture. This only applies to volume textures. + + int Depth + + + + The number of elements in the array. + + int ArraySize + + + + The maximum number of mipmap levels in the texture. See the remarks in . Using 0 or D3DX11_DEFAULT will cause a full mipmap chain to be created. + + int MipLevels + + + + Miscellaneous resource properties specified with a flag. + + D3D11_RESOURCE_MISC_FLAG MiscFlags + + + + A enumeration specifying the format the texture will be in after it is loaded. + + DXGI_FORMAT Format + + + + A value, which identifies the type of resource. + + D3D11_RESOURCE_DIMENSION ResourceDimension + + + + A value, which identifies the image format. + + D3DX11_IMAGE_FILE_FORMAT ImageFileFormat + + + + Retrieves information about a given image file. + + File name of image to retrieve information about. + If the function succeeds, returns a filled with the description of the data in the source file. else returns null + HRESULT D3DX11GetImageInfoFromFileW([None] const wchar_t* pSrcFile,[None] ID3DX11ThreadPump* pPump,[None] D3DX11_IMAGE_INFO* pSrcInfo,[None] HRESULT* pHResult) + + + + Retrieves information about a given image file from a memory location. + + an array to the image in memory + If the function succeeds, returns a filled with the description of the data from the image memory. else returns null + HRESULT D3DX11GetImageInfoFromFileW([None] const wchar_t* pSrcFile,[None] ID3DX11ThreadPump* pPump,[None] D3DX11_IMAGE_INFO* pSrcInfo,[None] HRESULT* pHResult) + + + + Optionally provide information to texture loader APIs to control how textures get loaded. A value of D3DX11_DEFAULT for any of these parameters will cause D3DX to automatically pick use the value from the source file. + + + When initializing the structure, you may set any member to D3DX11_DEFAULT and D3DX will initialize it with a default value from the source texture when the texture is loaded. This structure can be used by APIs that: Create resources, such as {{D3DX11CreateTextureFromFile}} and {{D3DX11CreateShaderResourceViewFromFile}}. Create data processors, such as {{D3DX11CreateAsyncTextureInfoProcessor}} or + {{D3DX11CreateAsyncShaderResourceViewProcessor}}. The default values are: + Width = D3DX11_DEFAULT; Height = D3DX11_DEFAULT; Depth = D3DX11_DEFAULT; FirstMipLevel = D3DX11_DEFAULT; MipLevels = D3DX11_DEFAULT; Usage = (D3D11_USAGE) D3DX11_DEFAULT; BindFlags = D3DX11_DEFAULT; CpuAccessFlags = D3DX11_DEFAULT; MiscFlags = D3DX11_DEFAULT; Format = DXGI_FORMAT_FROM_FILE; Filter = D3DX11_DEFAULT; MipFilter = D3DX11_DEFAULT; pSrcInfo = NULL; + + Here is a brief example that uses this structure to supply the pixel format when loading a texture. For the complete code, see HDRFormats10.cpp in {{HDRToneMappingCS11 Sample}}. + ID3D11ShaderResourceView* pCubeRV = NULL; + WCHAR strPath[MAX_PATH]; + D3DX11_IMAGE_LOAD_INFO LoadInfo; DXUTFindDXSDKMediaFileCch( strPath, MAX_PATH, L"Light Probes\\uffizi_cross.dds" ); LoadInfo.Format = DXGI_FORMAT_R16G16B16A16_FLOAT; hr = D3DX11CreateShaderResourceViewFromFile( pd3dDevice, strPath, &LoadInfo, NULL, &pCubeRV, NULL ); + + + + D3DX11_IMAGE_LOAD_INFO + + + + The default value for load options. + + + + + The target width of the texture. If the actual width of the texture is larger or smaller than this value then the texture will be scaled up or down to fit this target width. + + int Width + + + + The target height of the texture. If the actual height of the texture is larger or smaller than this value then the texture will be scaled up or down to fit this target height. + + int Height + + + + The depth of the texture. This only applies to volume textures. + + int Depth + + + + The highest resolution mipmap level of the texture. If this is greater than 0, then after the texture is loaded FirstMipLevel will be mapped to mipmap level 0. + + int FirstMipLevel + + + + The maximum number of mipmap levels in the texture. See the remarks in . Using 0 or D3DX11_DEFAULT will cause a full mipmap chain to be created. + + int MipLevels + + + + The way the texture resource is intended to be used. See . + + D3D11_USAGE Usage + + + + The pipeline stages that the texture will be allowed to bind to. See . + + D3D11_BIND_FLAG BindFlags + + + + The access permissions the cpu will have for the texture resource. See . + + D3D11_CPU_ACCESS_FLAG CpuAccessFlags + + + + Miscellaneous resource properties (see ). + + D3D11_RESOURCE_MISC_FLAG MiscFlags + + + + A enumeration indicating the format the texture will be in after it is loaded. + + DXGI_FORMAT Format + + + + Filter the texture using the specified filter (only when resampling). See . + + D3DX11_FILTER_FLAG Filter + + + + Filter the texture mip levels using the specified filter (only if generating mipmaps). Valid values are D3DX11_FILTER_NONE, D3DX11_FILTER_POINT, D3DX11_FILTER_LINEAR, or D3DX11_FILTER_TRIANGLE. See . + + D3DX11_FILTER_FLAG MipFilter + + + + Information about the original image. See . Can be obtained with {{D3DX11GetImageInfoFromFile}}, , or {{D3DX11GetImageInfoFromResource}}. + + D3DX11_IMAGE_INFO* pSrcInfo + + + + Describes parameters used to load a texture from another texture. + + + This structure is used in a call to . The default values are: + pSrcBox = NULL; pDstBox = NULL; SrcFirstMip = 0; DstFirstMip = 0; NumMips = D3DX11_DEFAULT; SrcFirstElement = 0; DstFirstElement = 0; NumElements = D3DX11_DEFAULT; Filter = D3DX11_DEFAULT; MipFilter = D3DX11_DEFAULT; + + + + D3DX11_TEXTURE_LOAD_INFO + + + + Source texture box (see ). + + D3D11_BOX* pSrcBox + + + + Destination texture box (see ). + + D3D11_BOX* pDstBox + + + + Source texture mipmap level, see {{D3D11CalcSubresource}} for more detail. + + int SrcFirstMip + + + + Destination texture mipmap level, see {{D3D11CalcSubresource}} for more detail. + + int DstFirstMip + + + + Number of mipmap levels in the source texture. + + int NumMips + + + + First element of the source texture. + + int SrcFirstElement + + + + First element of the destination texture. + + int DstFirstElement + + + + Number of elements to load. + + int NumElements + + + + Filtering options during resampling (see ). + + D3DX11_FILTER_FLAG Filter + + + + Filtering options when generating mip levels (see ). + + D3DX11_FILTER_FLAG MipFilter + + + + Source texture box (see ). + + D3D11_BOX* pSrcBox + + + + Destination texture box (see ). + + D3D11_BOX* pDstBox + + + + Describes an FFT. + + D3DX11_FFT_DESC + + + + Number of dimension in the FFT. + + int NumDimensions + + + + Combination of flags indicating the dimensions to transform. + + D3DX11_FFT_DIM_MASK DimensionMask + + + + flag indicating the type of data being transformed. + + D3DX11_FFT_DATA_TYPE Type + + + + Length of each dimension in the FFT. + + int ElementLengths[32] + + + + Buffer requirements for an FFT. + + + The D3DX11_FFT_BUFFER_INFO structure is initialized by a call to one of the functions (see {{D3DX Functions}}). + + D3DX11_FFT_BUFFER_INFO + + + + Number of temporary buffers needed. Allowed range is 0 to D3DX11_FFT_MAX_TEMP_BUFFERS. + + int NumTempBufferSizes + + + + Minimum sizes (in FLOATs) of temporary buffers. + + int TempBufferFloatSizes[4] + + + + Number of precompute buffers required. Allowed range is 0 to D3DX11_FFT_MAX_PRECOMPUTE_BUFFERS. + + int NumPrecomputeBufferSizes + + + + Minimum sizes (in FLOATs) for precompute buffers. + + int PrecomputeBufferFloatSizes[4] + + + + Properties defining the way a buffer is bound to the pipeline as a target for stream output operations. + + + + + Initializes a new instance of the struct. + + The buffer being bound. + The offset to the first vertex (in bytes). + + + + Gets or sets the buffer being bound. + + + + + Gets or sets the offset from the start of the buffer of the first vertex to use (in bytes). + + + + + Properties defining the way a buffer (containing vertex data) is bound + to the pipeline for rendering. + + + + + Initializes a new instance of the struct. + + The buffer being bound. + The stride between vertex element (in bytes). + The offset to the first vertex (in bytes). + + + + Gets or sets the buffer being bound. + + + + + Gets or sets the stride between vertex elements in the buffer (in bytes). + + + + + Gets or sets the offset from the start of the buffer of the first vertex to use (in bytes). + + + + diff --git a/Libs/SharpDX.DirectSound.dll b/Libs/SharpDX.DirectSound.dll new file mode 100644 index 0000000000000000000000000000000000000000..0369222df8100b4d0cc08da6bde4cd13481afe32 GIT binary patch literal 56320 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 literal 0 HcmV?d00001 diff --git a/Libs/SharpDX.DirectSound.xml b/Libs/SharpDX.DirectSound.xml new file mode 100644 index 0000000..e4c702a --- /dev/null +++ b/Libs/SharpDX.DirectSound.xml @@ -0,0 +1,4816 @@ + + + + SharpDX.DirectSound + + + + + No documentation. + + DS3DBUFFER + + + + Initializes a new instance of the class. + + + + + No documentation. + + int dwSize + + + + No documentation. + + D3DVECTOR vPosition + + + + No documentation. + + D3DVECTOR vVelocity + + + + No documentation. + + int dwInsideConeAngle + + + + No documentation. + + int dwOutsideConeAngle + + + + No documentation. + + D3DVECTOR vConeOrientation + + + + No documentation. + + int lConeOutsideVolume + + + + No documentation. + + D3DVALUE flMinDistance + + + + No documentation. + + D3DVALUE flMaxDistance + + + + No documentation. + + int dwMode + + + + The DSCAPS structure describes the capabilities of a device. It is used by the {{IDirectSound8::GetCaps}} method. + + DSCAPS + + + + Initializes a new instance of the class. + + + + + Size of the structure, in bytes. This member must be initialized before the structure is used. + + int dwSize + + + + Flags describing device capabilities. Can include the values shown in the following table. Value + Description + DSCAPS_CERTIFIED + The driver has been tested and certified by Microsoft. This flag is always set for WDM drivers. To test for certification, use . + DSCAPS_CONTINUOUSRATE + The device supports all sample rates between the dwMinSecondarySampleRate and dwMaxSecondarySampleRate member values. Typically, this means that the actual output rate will be within +/- 10 hertz (Hz) of the requested frequency. + DSCAPS_EMULDRIVER + The device does not have a DirectSound driver installed, so it is being emulated through the waveform-audio functions. Performance degradation should be expected. + DSCAPS_PRIMARY16BIT + The device supports a primary buffer with 16-bit samples. + DSCAPS_PRIMARY8BIT + The device supports primary buffers with 8-bit samples. + DSCAPS_PRIMARYMONO + The device supports monophonic primary buffers. + DSCAPS_PRIMARYSTEREO + The device supports stereo primary buffers. + DSCAPS_SECONDARY16BIT + The device supports hardware-mixed secondary sound buffers with 16-bit samples. + DSCAPS_SECONDARY8BIT + The device supports hardware-mixed secondary buffers with 8-bit samples. + DSCAPS_SECONDARYMONO + The device supports hardware-mixed monophonic secondary buffers. + DSCAPS_SECONDARYSTEREO + The device supports hardware-mixed stereo secondary buffers. + + + DSCAPS_FLAGS dwFlags + + + + Minimum and maximum sample rate specifications that are supported by this device's hardware secondary sound buffers. + + int dwMinSecondarySampleRate + + + + Number of primary buffers supported. This value will always be 1. + + int dwMaxSecondarySampleRate + + + + Number of buffers that can be mixed in hardware. This member can be less than the sum of dwMaxHwMixingStaticBuffers and dwMaxHwMixingStreamingBuffers. Resource tradeoffs frequently occur. + + int dwPrimaryBuffers + + + + Maximum number of static buffers. + + int dwMaxHwMixingAllBuffers + + + + Maximum number of streaming sound buffers. + + int dwMaxHwMixingStaticBuffers + + + + Number of unallocated buffers. On WDM drivers, this includes dwFreeHw3DAllBuffers. + + int dwMaxHwMixingStreamingBuffers + + + + Number of unallocated static buffers. + + int dwFreeHwMixingAllBuffers + + + + Number of unallocated streaming buffers. + + int dwFreeHwMixingStaticBuffers + + + + Maximum number of 3D buffers. + + int dwFreeHwMixingStreamingBuffers + + + + Maximum number of static 3D buffers. + + int dwMaxHw3DAllBuffers + + + + Maximum number of streaming 3D buffers. + + int dwMaxHw3DStaticBuffers + + + + Number of unallocated 3D buffers. + + int dwMaxHw3DStreamingBuffers + + + + Number of unallocated static 3D buffers. + + int dwFreeHw3DAllBuffers + + + + Number of unallocated streaming 3D buffers. + + int dwFreeHw3DStaticBuffers + + + + Size, in bytes, of the amount of memory on the sound card that stores static sound buffers. + + int dwFreeHw3DStreamingBuffers + + + + Size, in bytes, of the free memory on the sound card. + + int dwTotalHwMemBytes + + + + Size, in bytes, of the largest contiguous block of free memory on the sound card. + + int dwFreeHwMemBytes + + + + The rate, in kilobytes per second, at which data can be transferred to hardware static sound buffers. This and the number of bytes transferred determines the duration of a call to the {{IDirectSoundBuffer8::Unlock}} method. + + int dwMaxContigFreeHwMemBytes + + + + The processing overhead, as a percentage of main processor cycles, needed to mix software buffers. This varies according to the bus type, the processor type, and the clock speed. + + int dwUnlockTransferRateHwBuffers + + + + Not used. + + int dwPlayCpuOverheadSwBuffers + + + + Not used. + + int dwReserved1 + + + + No documentation. + + int dwReserved2 + + + + No documentation. + + IDirectSoundCaptureBuffer8 + + + + No documentation. + + IDirectSoundCaptureBuffer + + + + The Lock method locks a portion of the buffer. Locking the buffer returns references into the buffer, allowing the application to read or write audio data into memory. + + Offset, in bytes, from the start of the buffer to the point where the lock begins. + Size, in bytes, of the portion of the buffer to lock. Because the buffer is conceptually circular, this number can exceed the number of bytes between dwOffset and the end of the buffer. + Flags modifying the lock event. The following flags are defined: ValueDescription DSBLOCK_FROMWRITECURSORStart the lock at the write cursor. The dwOffset parameter is ignored. DSBLOCK_ENTIREBUFFERLock the entire buffer. The dwBytes parameter is ignored. + Address of a variable that receives a pointer to the second locked part of the capture buffer. If NULL is returned, the ppvAudioPtr1 parameter points to the entire locked portion of the capture buffer. + Address of a variable that receives a pointer to the first locked part of the buffer. + HRESULT IDirectSoundCaptureBuffer::Lock([None] int dwOffset,[None] int dwBytes,[Out] void** ppvAudioPtr1,[Out] int* pdwAudioBytes1,[Out] void** ppvAudioPtr2,[Out, Optional] int* pdwAudioBytes2,[None] int dwFlags) + + + + The Unlock method releases a locked sound buffer. + + Address of the value retrieved in the ppvAudioPtr1 parameter of the {{Lock}} method. + Address of the value retrieved in the ppvAudioPtr2 parameter of the IDirectSoundBuffer8::Lock method. + No documentation. + HRESULT IDirectSoundBuffer::Unlock([In, Buffer] void* pvAudioPtr1,[None] int dwAudioBytes1,[In, Buffer, Optional] void* pvAudioPtr2,[None] int dwAudioBytes2) + + + + Writes data to the buffer. + + + + + + Writes data to the buffer. + + + + + + Initializes a new instance of the class. + + The native pointer. + + + + The GetCaps method retrieves the capabilities of the buffer. + + Pointer to a structure that receives information about the capture buffer. On input, the dwSize member must specify the size of the structure in bytes. + No documentation. + HRESULT IDirectSoundCaptureBuffer::GetCaps([Out] LPDSCBCAPS pDSCBCaps) + + + + The GetCurrentPosition method retrieves the positions of the capture and read cursors in the buffer. + + Address of a variable that receives the offset from the start of the buffer, in bytes, of the capture cursor. The parameter can be NULL if this value is not wanted. + Address of a variable that receives the offset from the start of the buffer, in bytes, of the read cursor. + No documentation. + HRESULT IDirectSoundCaptureBuffer::GetCurrentPosition([Out, Optional] int* pdwCapturePosition,[Out, Optional] int* pdwReadPosition) + + + + The GetFormat method retrieves the waveform format of the capture buffer. + + Address of a structure that receives a description of the sound data in the capture buffer. To retrieve the buffer size needed to contain the format description, specify NULL.; in this case, the DWORD pointed to by the pdwSizeWritten parameter receives the size of the structure needed to receive complete format information. + Size, in bytes, of the WAVEFORMATEX structure. DirectSoundCapture writes, at most, dwSizeAllocated bytes to the structure. + Address of a variable that receives the number of bytes written to the WAVEFORMATEX structure; or, if pwfxFormat is NULL, the size of the WAVEFORMATEX structure that would be necessary to receive the information. This parameter can be NULL if the value is not wanted. + No documentation. + HRESULT IDirectSoundCaptureBuffer::GetFormat([In] void* pwfxFormat,[None] int dwSizeAllocated,[Out, Optional] int* pdwSizeWritten) + + + + The GetStatus method retrieves the status of the capture buffer. + + Address of a variable that receives the status of the capture buffer. The status can be set to one or more of the following: ValueDescription DSCBSTATUS_CAPTURINGThe buffer is capturing audio data. DSCBSTATUS_LOOPINGThe buffer is looping. + No documentation. + HRESULT IDirectSoundCaptureBuffer::GetStatus([Out] DSCBSTATUS_FLAGS* pdwStatus) + + + + The Lock method locks a portion of the buffer. Locking the buffer returns references into the buffer, allowing the application to read or write audio data into memory. + + Offset, in bytes, from the start of the buffer to the point where the lock begins. + Size, in bytes, of the portion of the buffer to lock. Because the buffer is conceptually circular, this number can exceed the number of bytes between dwOffset and the end of the buffer. + Address of a variable that receives a reference to the first locked part of the buffer. + Address of a variable that receives the number of bytes in the block at ppvAudioPtr1. If this value is less than dwBytes, the lock has wrapped and ppvAudioPtr2 points to a second block of data at the beginning of the buffer. + Address of a variable that receives a reference to the second locked part of the capture buffer. If NULL is returned, the ppvAudioPtr1 parameter points to the entire locked portion of the capture buffer. + Address of a variable that receives the number of bytes in the block at ppvAudioPtr2. If ppvAudioPtr2 is NULL, this value is zero. + Flags modifying the lock event. This value can be zero or the following flag: ValueDescription DSCBLOCK_ENTIREBUFFERIgnore dwBytes and lock the entire capture buffer. + No documentation. + HRESULT IDirectSoundCaptureBuffer::Lock([None] int dwOffset,[None] int dwBytes,[Out] void** ppvAudioPtr1,[Out] int* pdwAudioBytes1,[Out] void** ppvAudioPtr2,[Out, Optional] int* pdwAudioBytes2,[None] int dwFlags) + + + + The Start method begins capturing data into the buffer. If the buffer is already capturing, the method has no effect. + + Flags that specify the behavior of the buffer when capturing sound data. The following flag is defined: ValueDescription DSCBSTART_LOOPINGAfter the end of the buffer is reached, capture restarts at the beginning and continues until explicitly stopped. + No documentation. + HRESULT IDirectSoundCaptureBuffer::Start([None] BOOL dwFlags) + + + + The Stop method stops the buffer so that it is no longer capturing data. If the buffer is not capturing, the method has no effect. + + No documentation. + HRESULT IDirectSoundCaptureBuffer::Stop() + + + + The Unlock method unlocks the buffer. + + Address of the value retrieved in the ppvAudioPtr1 parameter of the {{Lock}} method. + Number of bytes read from the pvAudioPtr1 parameter. See Remarks. + Address of the value retrieved in the ppvAudioPtr2 parameter of the IDirectSoundCaptureBuffer8::Lock method. + Number of bytes read from the pvAudioPtr2 parameter. See Remarks. + No documentation. + HRESULT IDirectSoundCaptureBuffer::Unlock([In, Buffer] void* pvAudioPtr1,[None] int dwAudioBytes1,[In, Buffer, Optional] void* pvAudioPtr2,[None] int dwAudioBytes2) + + + + True if the buffer is currently capturing. + + + + + The offset from the start of the buffer, in bytes, of the capture cursor. + + + + + The offset from the start of the buffer, in bytes, of the read cursor. + + + + + True if the capture buffer is looping. + + + + + Gets the waveform format of the capture buffer. + + The format. + + + + The GetCaps method retrieves the capabilities of the buffer. + + HRESULT IDirectSoundCaptureBuffer::GetCaps([Out] LPDSCBCAPS pDSCBCaps) + + + + The GetStatus method retrieves the status of the capture buffer. + + HRESULT IDirectSoundCaptureBuffer::GetStatus([Out] DSCBSTATUS_FLAGS* pdwStatus) + + + + Creates a buffer for capturing waveform audio. + + a reference to an instance of + a structure containing values for the capture buffer being created. + No documentation. + HRESULT IDirectSoundCapture::CreateCaptureBuffer([In] LPCDSCBUFFERDESC pcDSCBufferDesc,[Out] LPDIRECTSOUNDCAPTUREBUFFER* ppDSCBuffer,[None] IUnknown* pUnkOuter) + + + + Retrieves an interface to an effect object associated with the buffer. + + Index of the object within objects of that class in the path. See Remarks. + an effect object associated with the buffer + HRESULT IDirectSoundCaptureBuffer8::GetObjectInPath([In] GUID* rguidObject,[None] int dwIndex,[In] GUID* rguidInterface,[Out] void** ppObject) + + + + Retrieves the status of capture effects. + + + + + + + Sets the notification positions. + + The positions. + + + + + Initializes a new instance of the class. + + The native pointer. + + + + The GetObjectInPath method retrieves an interface to an effect object associated with the buffer. + + Value of type REFGUID that specifies the unique class identifier of the object being searched for, such as GUID_DSCFX_CLASS_AEC. + Index of the object within objects of that class in the path. See Remarks. + Unique identifier of the desired interface, such as IID_IDirectSoundCaptureFXAec8. + Address of a variable that receives the desired interface reference. + No documentation. + HRESULT IDirectSoundCaptureBuffer8::GetObjectInPath([In] GUID* rguidObject,[None] int dwIndex,[In] GUID* rguidInterface,[Out] void** ppObject) + + + + The GetFXStatus method retrieves the status of capture effects. + + Number of elements in the pdwFXStatus array. + Address of an array of DWORD variables that receive the status of each effect. This should contain the same number of elements as the array passed in the dwFXCount member of the structure passed to {{DirectSoundFullDuplexCreate8}} or {{IDirectSoundCapture8::CreateCaptureBuffer}}. The possible values returned in the array are as follows: ValueDescription DSCFXR_LOCHARDWAREEffect is instantiated in hardware. DSCFXR_LOCSOFTWAREEffect is instantiated in software. + No documentation. + HRESULT IDirectSoundCaptureBuffer8::GetFXStatus([None] int dwEffectsCount,[Out, Buffer] DSCFX_ENUM* pdwFXStatus) + + + + No documentation. + + DSCBCAPS + + + + Initializes a new instance of the class. + + + + + No documentation. + + int dwSize + + + + No documentation. + + DSCBCAPS_FLAGS dwFlags + + + + No documentation. + + int dwBufferBytes + + + + No documentation. + + int dwReserved + + + + No documentation. + + DSCBUFFERDESC + + + + Initializes a new instance of the class. + + + + + No documentation. + + int dwSize + + + + No documentation. + + DSCBCAPS_FLAGS dwFlags + + + + No documentation. + + int dwBufferBytes + + + + No documentation. + + int dwReserved + + + + No documentation. + + WAVEFORMATEX* lpwfxFormat + + + + No documentation. + + int dwFXCount + + + + No documentation. + + LPDSCEFFECTDESC lpDSCFXDesc + + + + Gets a value indicating whether [wave mapped]. + + true if [wave mapped]; otherwise, false. + + + + Gets a value indicating whether [control effects]. + + true if [control effects]; otherwise, false. + + + + Gets or sets the format. + + The format. + + + + Describes effects supported by hardware for the buffer. + + + + + The DSCCAPS structure describes the capabilities of the capture device. It is used by the {{IDirectSoundCapture8::GetCaps}} method. + + DSCCAPS + + + + Initializes a new instance of the class. + + + + + Size of the structure, in bytes. This member must be initialized before the structure is used. + + int dwSize + + + + Specifies device capabilities. Can be zero or one or more of the following flags. Value + Description + DSCCAPS_CERTIFIED + The driver for the device is a certified WDM driver. + DSCCAPS_EMULDRIVER + There is no DirectSoundCapture driver for the device, so the standard waveform audio functions are being used. + DSCCAPS_MULTIPLECAPTURE + Multiple capture objects can be used simultaneously on the capture device. + + + int dwFlags + + + + Standard formats that are supported. These are equivalent to the values in the WAVEINCAPS structure used in the Win32 waveform audio functions, and are defined in MMSystem.h in the Platform SDK. + + int dwFormats + + + + Number of channels supported by the device, where 1 is mono, 2 is stereo, and so on. + + int dwChannels + + + + No documentation. + + DSCEFFECTDESC + + + + Initializes a new instance of the class. + + + + + No documentation. + + int dwSize + + + + No documentation. + + DSCFX_ENUM dwFlags + + + + No documentation. + + GUID guidDSCFXClass + + + + No documentation. + + GUID guidDSCFXInstance + + + + No documentation. + + int dwReserved1 + + + + No documentation. + + int dwReserved2 + + + + No documentation. + + IDirectSoundFXChorus + + + + Default number of milliseconds the input is delayed before it is played back. The default value is 50. + + + + + Maximum number of milliseconds the input is delayed before it is played back. + + + + + Minimum number of milliseconds the input is delayed before it is played back. + + + + + Default percentage by which the delay time is modulated by the low-frequency oscillator, in hundredths of a percentage point. The default value is 10. + + + + + Maximum percentage by which the delay time is modulated by the low-frequency oscillator, in hundredths of a percentage point. + + + + + Minimum percentage by which the delay time is modulated by the low-frequency oscillator, in hundredths of a percentage point. + + + + + Default percentage of output signal to feed back into the effect's input. The default value is 25. + + + + + Maximum percentage of output signal to feed back into the effect's input. + + + + + Minimum percentage of output signal to feed back into the effect's input. + + + + + Default frequency of the LFO. The default value is 1.1. + + + + + Maximum frequency of the LFO. + + + + + Minimum frequency of the LFO. + + + + + Positive 180 phase differential between left and right LFOs. + + + + + Positive 90 phase differential between left and right LFOs. + + + + + Default phase differential between left and right LFOs. The default value is Phase90. + + + + + Maximum phase differential between left and right LFOs. + + + + + Minimum phase differential between left and right LFOs. + + + + + Negative 180 phase differential between left and right LFOs. + + + + + Negative 90 phase differential between left and right LFOs. + + + + + Zero phase differential between left and right LFOs. + + + + + Default waveform shape of the LFO. By default, the waveform is a sine. + + + + + Sine waveform shape of the LFO. + + + + + Triangle waveform shape of the LFO. + + + + + Default ratio of wet (processed) signal to dry (unprocessed) signal. + + + + + Maximum ratio of wet (processed) signal to dry (unprocessed) signal. + + + + + Minimum ratio of wet (processed) signal to dry (unprocessed) signal. + + + + + Initializes a new instance of the class. + + The native pointer. + + + + The SetAllParameters method sets the chorus parameters of a buffer. + + Address of a structure that specifies the effect parameters. + No documentation. + HRESULT IDirectSoundFXChorus::SetAllParameters([In] LPCDSFXChorus pcDsFxChorus) + + + + The GetAllParameters method retrieves the chorus parameters of a buffer. + + Address of a structure that receives the effect parameters. + No documentation. + HRESULT IDirectSoundFXChorus::GetAllParameters([Out] LPDSFXChorus pDsFxChorus) + + + + The GetAllParameters method retrieves the chorus parameters of a buffer. + + HRESULT IDirectSoundFXChorus::GetAllParameters([Out] LPDSFXChorus pDsFxChorus) + + + + No documentation. + + IDirectSoundFXCompressor + + + + Default time before compression reaches its full value, in decibels (dB). The default value is 10 ms. + + + + + Maximum time before compression reaches its full value, in decibels (dB). + + + + + Minimum time before compression reaches its full value, in decibels (dB). + + + + + Default output gain of signal after compression, in decibels (dB). The default value is 0 dB. + + + + + Maximum output gain of signal after compression, in decibels (dB). + + + + + Minimum output gain of signal after compression, in decibels (dB). + + + + + Default time after threshold is reached before attack phase is started, in milliseconds. The default value is 4 ms. + + + + + Maximum time after threshold is reached before attack phase is started, in milliseconds. + + + + + Minimum time after threshold is reached before attack phase is started, in milliseconds. + + + + + Default compression ratio. The default value is 3, which means 3:1 compression. + + + + + Maximum compression ratio. + + + + + Minimum compression ratio. + + + + + Default speed at which compression is stopped after input drops below Threshold, in miliseconds. The default value is 200 ms. + + + + + Maximum speed at which compression is stopped after input drops below Threshold, in miliseconds. + + + + + Minimum speed at which compression is stopped after input drops below Threshold, in miliseconds. + + + + + Default point at which compression begins, in decibels, in decibels (dB). The default value is -20 dB. + + + + + Maximum point at which compression begins, in decibels, in decibels (dB). + + + + + Minimum point at which compression begins, in decibels, in decibels (dB). + + + + + Initializes a new instance of the class. + + The native pointer. + + + + The SetAllParameters method sets the compression parameters of a buffer. + + Address of a structure that specifies the effect parameters. + No documentation. + HRESULT IDirectSoundFXCompressor::SetAllParameters([In] LPCDSFXCompressor pcDsFxCompressor) + + + + The GetAllParameters method retrieves the compression parameters of a buffer. + + Address of a structure that receives the effect parameters. + No documentation. + HRESULT IDirectSoundFXCompressor::GetAllParameters([Out] LPDSFXCompressor pDsFxCompressor) + + + + The GetAllParameters method retrieves the compression parameters of a buffer. + + HRESULT IDirectSoundFXCompressor::GetAllParameters([Out] LPDSFXCompressor pDsFxCompressor) + + + + Contains information about a DirectSound device. + + + + + Initializes a new instance of the class. + + The driver GUID. + The description. + Name of the module. + + + + Identifies the DirectSound driver being enumerated + + + + + String that provides a textual description of the DirectSound device. + + + + + String that specifies the module name of the DirectSound driver corresponding to this device. + + + + + No documentation. + + IDirectSound8 + + + + No documentation. + + IDirectSound + + + + Initializes a new instance of the class. + + The native pointer. + + + + The CreateSoundBuffer method creates a sound buffer object to manage audio samples. + + Address of a structure that describes the sound buffer to create. + Address of a variable that receives the IDirectSoundBuffer interface of the new buffer object. Use QueryInterface to obtain . IDirectSoundBuffer8 is not available for the primary buffer. + Address of the controlling object's IUnknown interface for COM aggregation. Must be NULL. + No documentation. + HRESULT IDirectSound::CreateSoundBuffer([In] LPCDSBUFFERDESC pcDSBufferDesc,[Out] void* ppDSBuffer,[None] IUnknown* pUnkOuter) + + + + The GetCaps method retrieves the capabilities of the hardware device that is represented by the device object. + + Address of a structure that receives the capabilities of this sound device. + No documentation. + HRESULT IDirectSound::GetCaps([Out] LPDSCAPS pDSCaps) + + + + The DuplicateSoundBuffer method creates a new secondary buffer that shares the original buffer's memory. + + Address of the IDirectSoundBuffer or interface of the buffer to duplicate. + Address of a variable that receives the IDirectSoundBuffer interface reference for the new buffer. + No documentation. + HRESULT IDirectSound::DuplicateSoundBuffer([In] LPDIRECTSOUNDBUFFER pDSBufferOriginal,[Out] void* ppDSBufferDuplicate) + + + + The SetCooperativeLevel method sets the cooperative level of the application for this sound device. + + Handle to the application window. + Requested level. Specify one of the values shown in the following table. ValueDescription DSSCL_EXCLUSIVEFor DirectX 8.0 and later, has the same effect as DSSCL_PRIORITY. For previous versions, sets the application to the exclusive level. This means that when it has the input focus, the application will be the only one audible; sounds from applications with the DSBCAPS_GLOBALFOCUS flag set will be muted. With this level, it also has all the privileges of the DSSCL_PRIORITY level. DirectSound will restore the hardware format, as specified by the most recent call to the {{SetFormat}} method, after the application gains the input focus. DSSCL_NORMALSets the normal level. This level has the smoothest multitasking and resource-sharing behavior, but because it does not allow the primary buffer format to change, output is restricted to the default 8-bit format. DSSCL_PRIORITYSets the priority level. Applications with this cooperative level can call the {{SetFormat}} and {{Compact}} methods. DSSCL_WRITEPRIMARYSets the write-primary level. The application has write access to the primary buffer. No secondary buffers can be played. This level cannot be set if the DirectSound driver is being emulated for the device; that is, if the {{GetCaps}} method returns the DSCAPS_EMULDRIVER flag in the structure. + No documentation. + HRESULT IDirectSound::SetCooperativeLevel([None] void* hwnd,[None] DSSCL_ENUM dwLevel) + + + + The Compact method has no effect. + + No documentation. + HRESULT IDirectSound::Compact() + + + + The GetSpeakerConfig method retrieves the speaker configuration. + + Address of the speaker configuration (see remarks in {{IDirectSound8::SetSpeakerConfig}}). + No documentation. + HRESULT IDirectSound::GetSpeakerConfig([Out] int* pdwSpeakerConfig) + + + + The SetSpeakerConfig method specifies the speaker configuration of the device. + + The speaker configuration. See remarks. + No documentation. + HRESULT IDirectSound::SetSpeakerConfig([None] int dwSpeakerConfig) + + + + The GetCaps method retrieves the capabilities of the hardware device that is represented by the device object. + + HRESULT IDirectSound::GetCaps([Out] LPDSCAPS pDSCaps) + + + + Initializes a new instance of the class. + + + + + Retrieves the speaker configuration of the device. + + + + + + + Sets the speaker configuration of the device. + + + + + + + Enumerates the DirectSound devices installed in the system. + + A collection of the devices found. + + + + Initializes a new instance of the class. + + The native pointer. + + + + The VerifyCertification method ascertains whether the device driver is certified for DirectX. + + Address of a DWORD variable that receives one of the values shown in the following table. ValueDescription DS_CERTIFIEDDriver is certified for DirectSound. DS_UNCERTIFIEDDriver is not certified for DirectSound. + No documentation. + HRESULT IDirectSound8::VerifyCertification([Out] int* pdwCertified) + + + + Verifies the certification. + + Return true if the driver is certified + + + + No documentation. + + IDirectSoundCapture + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + + + + + + Enumerates the DirectSoundCapture devices installed in the system. + + A collection of the devices found. + + + + Initializes a new instance of the class. + + The native pointer. + + + + The CreateCaptureBuffer method creates a buffer for capturing waveform audio. + + Pointer to a structure containing values for the capture buffer being created. + Address of a variable that receives an IDirectSoundCaptureBuffer interface reference. Use QueryInterface to obtain . See Remarks. + Address of the controlling object's IUnknown interface for COM aggregation. Must be NULL. + No documentation. + HRESULT IDirectSoundCapture::CreateCaptureBuffer([In] LPCDSCBUFFERDESC pcDSCBufferDesc,[Out] LPDIRECTSOUNDCAPTUREBUFFER* ppDSCBuffer,[None] IUnknown* pUnkOuter) + + + + The GetCaps method retrieves the capabilities of the capture device. + + Pointer to a structure to be receive information about the capture device. When the method is called, the dwSize member must specify the size of the structure in bytes. + No documentation. + HRESULT IDirectSoundCapture::GetCaps([Out] LPDSCCAPS pDSCCaps) + + + + The GetCaps method retrieves the capabilities of the capture device. + + HRESULT IDirectSoundCapture::GetCaps([Out] LPDSCCAPS pDSCCaps) + + + + No documentation. + + IDirectSoundFXDistortion + + + + Default percentage of distortion intensity. + + + + + Maximum percentage of distortion intensity. + + + + + Minimum percentage of distortion intensity. + + + + + Default amount of signal change after distortion. + + + + + Maximum amount of signal change after distortion. + + + + + Minimum amount of signal change after distortion. + + + + + Default width of frequency band that determines range of harmonic content addition. + + + + + Maximum width of frequency band that determines range of harmonic content addition. + + + + + Minimum width of frequency band that determines range of harmonic content addition. + + + + + Default center frequency of harmonic content addition. + + + + + Maximum center frequency of harmonic content addition. + + + + + Minimum center frequency of harmonic content addition. + + + + + Default filter cutoff for high-frequency harmonics attenuation. + + + + + Maximum filter cutoff for high-frequency harmonics attenuation. + + + + + Minimum filter cutoff for high-frequency harmonics attenuation. + + + + + Initializes a new instance of the class. + + The native pointer. + + + + The SetAllParameters method sets the distortion parameters of a buffer. + + Address of a structure that specifies the effect parameters. + No documentation. + HRESULT IDirectSoundFXDistortion::SetAllParameters([In] LPCDSFXDistortion pcDsFxDistortion) + + + + The GetAllParameters method retrieves the distortion parameters of a buffer. + + Address of a structure that receives the effect parameters. + No documentation. + HRESULT IDirectSoundFXDistortion::GetAllParameters([Out] LPDSFXDistortion pDsFxDistortion) + + + + The GetAllParameters method retrieves the distortion parameters of a buffer. + + HRESULT IDirectSoundFXDistortion::GetAllParameters([Out] LPDSFXDistortion pDsFxDistortion) + + + + No documentation. + + IDirectSoundFXEcho + + + + Default percentage of output fed back into input. + + + + + Maximum percentage of output fed back into input. + + + + + Minimum percentage of output fed back into input. + + + + + Default delay for left channel, in milliseconds. + + + + + Maximum delay for left channel, in milliseconds. + + + + + Minimum delay for left channel, in milliseconds. + + + + + Default value that specifies whether to swap left and right delays with each successive echo. The default value is zero, meaning no swap. + + + + + Maximum value that specifies whether to swap left and right delays with each successive echo. The default value is zero, meaning no swap. + + + + + Minimum value that specifies whether to swap left and right delays with each successive echo. The default value is zero, meaning no swap. + + + + + Default delay for right channel, in milliseconds. + + + + + Maximum delay for right channel, in milliseconds. + + + + + Minimum delay for right channel, in milliseconds. + + + + + Default ratio of wet (processed) signal to dry (unprocessed) signal. + + + + + Maximum ratio of wet (processed) signal to dry (unprocessed) signal. + + + + + Minimum ratio of wet (processed) signal to dry (unprocessed) signal. + + + + + Initializes a new instance of the class. + + The native pointer. + + + + The SetAllParameters method sets the echo parameters of a buffer. + + Address of a structure that specifies the effect parameters. + No documentation. + HRESULT IDirectSoundFXEcho::SetAllParameters([In] LPCDSFXEcho pcDsFxEcho) + + + + The GetAllParameters method retrieves the echo parameters of a buffer. + + Address of a structure that receives the effect parameters. + No documentation. + HRESULT IDirectSoundFXEcho::GetAllParameters([Out] LPDSFXEcho pDsFxEcho) + + + + The GetAllParameters method retrieves the echo parameters of a buffer. + + HRESULT IDirectSoundFXEcho::GetAllParameters([Out] LPDSFXEcho pDsFxEcho) + + + + No documentation. + + IDirectSound3DBuffer + + + + Default cone angle, in degrees. + + + + + Default outside cone volume. Volume levels are expressed as attenuation, in hundredths of a decibel. + + + + + Default maximum distance, in meters. + + + + + Default minimum distance, in meters. + + + + + Maximum cone angle, in degrees. + + + + + Minimum cone angle, in degrees. + + + + + Initializes a new instance of the class. + + + + + + + Initializes a new instance of the class. + + The native pointer. + + + + The GetAllParameters method retrieves the 3D properties of the sound buffer. + + Address of a structure that receives the information describing the 3D characteristics of the sound buffer. + No documentation. + HRESULT IDirectSound3DBuffer::GetAllParameters([Out] LPDS3DBUFFER pDs3dBuffer) + + + + The GetConeAngles method retrieves the inside and outside angles of the sound projection cone. + + Addresses of a variable that receives the inside angle of the sound projection cone, in degrees. This is the angle within which the sound is at its normal volume. + Addresses of a variable that receives the outside angle of the sound projection cone, in degrees. This is the angle outside of which the sound is at its outside volume. + No documentation. + HRESULT IDirectSound3DBuffer::GetConeAngles([Out] int* pdwInsideConeAngle,[Out] int* pdwOutsideConeAngle) + + + + The GetConeOrientation method retrieves the orientation of the sound projection cone. + + Address of a D3DVECTOR structure that receives the orientation of the sound projection cone. The vector information represents the center of the sound cone. + No documentation. + HRESULT IDirectSound3DBuffer::GetConeOrientation([Out] D3DVECTOR* pvOrientation) + + + + The GetConeOutsideVolume method retrieves the volume of the sound outside the outside angle of the sound projection cone. + + Address of a variable that receives the cone outside volume for this buffer. + No documentation. + HRESULT IDirectSound3DBuffer::GetConeOutsideVolume([Out] int* plConeOutsideVolume) + + + + The GetMaxDistance method retrieves the maximum distance, which is the distance from the listener beyond which sounds in this buffer are no longer attenuated. + + Address of a variable that receives the maximum distance, in meters by default. D3DVALUE is defined as float. + No documentation. + HRESULT IDirectSound3DBuffer::GetMaxDistance([Out] D3DVALUE* pflMaxDistance) + + + + The GetMinDistance method retrieves the minimum distance, which is the distance from the listener at which sounds in this buffer begin to be attenuated. + + Address of a variable that receives the minimum distance, in meters by default. D3DVALUE is defined as float. + No documentation. + HRESULT IDirectSound3DBuffer::GetMinDistance([Out] D3DVALUE* pflMinDistance) + + + + The GetMode method retrieves the operation mode for 3D sound processing. + + Address of a variable that receives the mode setting. This value will be one of those in the following table. ValueDescription DS3DMODE_DISABLEProcessing of 3D sound is disabled. The sound seems to originate from the center of the listener's head. DS3DMODE_HEADRELATIVESound parameters (position, velocity, and orientation) are relative to the listener's parameters. In this mode, the absolute parameters of the sound are updated automatically as the listener's parameters change, so that the relative parameters remain constant. DS3DMODE_NORMALNormal processing. This is the default mode. + No documentation. + HRESULT IDirectSound3DBuffer::GetMode([Out] int* pdwMode) + + + + The GetPosition method retrieves the position of the sound source. + + Address of a structure that receives the position of the sound buffer. + No documentation. + HRESULT IDirectSound3DBuffer::GetPosition([Out] D3DVECTOR* pvPosition) + + + + The GetVelocity method retrieves the velocity of the sound source. + + Address of a structure that receives the sound buffer's velocity, in meters per second by default. + No documentation. + HRESULT IDirectSound3DBuffer::GetVelocity([Out] D3DVECTOR* pvVelocity) + + + + The SetAllParameters method sets all 3D sound buffer properties. + + Address of a structure that describes the 3D characteristics of the sound buffer. + Value that specifies when the setting should be applied. This value must be one of the following: ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DBuffer::SetAllParameters([In] LPCDS3DBUFFER pcDs3dBuffer,[None] int dwApply) + + + + The SetConeAngles method sets the inside and outside angles of the sound projection cone. + + Inside cone angle, in degrees. This is the angle within which the sound is at its normal volume. + Outside cone angle, in degrees. This is the angle outside of which the sound is at its outside volume. + Value that indicates when the setting should be applied. Must be one of the following: ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DBuffer::SetConeAngles([None] int dwInsideConeAngle,[None] int dwOutsideConeAngle,[None] int dwApply) + + + + The SetConeOrientation method sets the orientation of the sound projection cone. + + Value that specifies the x coordinate of the sound cone orientation vector. D3DVALUE is defined as float. + Value that specifies the y coordinate of the sound cone orientation vector. D3DVALUE is defined as float. + Value that specifies the z coordinate of the sound cone orientation vector. D3DVALUE is defined as float. + Value that specifies when the setting should be applied. This value must be one of the following: ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DBuffer::SetConeOrientation([None] D3DVALUE x,[None] D3DVALUE y,[None] D3DVALUE z,[None] int dwApply) + + + + The SetConeOutsideVolume method sets the volume of the sound outside the outside angle of the sound projection cone. + + Cone outside volume, in hundredths of a decibel. + Value that specifies when the setting should be applied. This value must be one of the those shown in the following table. ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DBuffer::SetConeOutsideVolume([None] int lConeOutsideVolume,[None] int dwApply) + + + + The SetMaxDistance method sets the maximum distance, which is the distance from the listener beyond which sounds in this buffer are no longer attenuated. + + Maximum distance, in meters by default. D3DVALUE is defined as float. + Value that specifies when the setting should be applied. This value must be one of the following: ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DBuffer::SetMaxDistance([None] D3DVALUE flMaxDistance,[None] int dwApply) + + + + The SetMinDistance method sets the minimum distance, which is the distance from the listener at which sounds in this buffer begin to be attenuated. + + Minimum distance, in meters by default. D3DVALUE is defined as float. + Value that specifies when the setting should be applied. This value must be one of the following: ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DBuffer::SetMinDistance([None] D3DVALUE flMinDistance,[None] int dwApply) + + + + The SetMode method sets the operation mode for 3D sound processing. + + Flag specifying the 3D sound processing mode to be set. The flags in the following table are defined. ValueDescription DS3DMODE_DISABLEProcessing of 3D sound is disabled. The sound seems to originate from the center of the listener's head. DS3DMODE_HEADRELATIVESound parameters (position, velocity, and orientation) are relative to the listener's parameters. In this mode, the absolute parameters of the sound are updated automatically as the listener's parameters change, so that the relative parameters remain constant. DS3DMODE_NORMALNormal processing. This is the default mode. + Value that specifies when the setting should be applied. This value must be one of those in the following table. ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DBuffer::SetMode([None] int dwMode,[None] int dwApply) + + + + The SetPosition method sets the position of the sound source. + + Value that specifies the x coordinate of the position vector. DirectSound may adjust these values to prevent floating-point overflow. D3DVALUE is defined as float. + Value that specifies the y coordinate of the position vector. DirectSound may adjust these values to prevent floating-point overflow. D3DVALUE is defined as float. + Value that specifies the z coordinate of the position vector. DirectSound may adjust these values to prevent floating-point overflow. D3DVALUE is defined as float. + Value that specifies when the setting should be applied. This value must be one of the following: ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DBuffer::SetPosition([None] D3DVALUE x,[None] D3DVALUE y,[None] D3DVALUE z,[None] int dwApply) + + + + The SetVelocity method sets the velocity of the sound source. + + Value that specifies the x coordinate of the velocity vector, in meters per second by default. DirectSound may adjust these values to prevent floating-point overflow. D3DVALUE is defined as float. + Value that specifies the y coordinate of the velocity vector, in meters per second by default. DirectSound may adjust these values to prevent floating-point overflow. D3DVALUE is defined as float. + Value that specifies the z coordinate of the velocity vector, in meters per second by default. DirectSound may adjust these values to prevent floating-point overflow. D3DVALUE is defined as float. + Value that specifies when the setting should be applied. This value must be one of the following: ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DBuffer::SetVelocity([None] D3DVALUE x,[None] D3DVALUE y,[None] D3DVALUE z,[None] int dwApply) + + + + Gets or sets all the parameters of a buffer + + + + + The orientation of the sound projection cone. + + + + + The volume of the sound outside the outside angle of the sound projection cone. + + + + + Settings are not applied until the application calls the SoundListener3D.CommitDeferredSettings() if true. + + + + + The inside angle of the sound projection cone. + + + + + The maximum distance, which is the distance from the listener beyond which sounds in this buffer are no longer attenuated. + + + + + The minimum distance, which is the distance from the listener at which sounds in this buffer begin to be attenuated. + + + + + The operation mode for 3-D sound processing. + + + + + The outside angle of the sound projection cone. + + + + + The position of the sound source. + + + + + The velocity of the sound source. + + + + + No documentation. + + DSEFFECTDESC + + + + Initializes a new instance of the class. + + + + + No documentation. + + int dwSize + + + + No documentation. + + int dwFlags + + + + No documentation. + + GUID guidDSFXClass + + + + No documentation. + + int* dwReserved1 + + + + No documentation. + + int* dwReserved2 + + + + Enumerator callback for DirectSound and DirectCaptureSound. + + + + + Initializes a new instance of the class. + + + + + Natives the pointer. + + + + + + Gets or sets the informations. + + The informations. + + + + No documentation. + + IDirectSoundFXFlanger + + + + Default number of milliseconds the input is delayed before it is played back. + + + + + Maximum number of milliseconds the input is delayed before it is played back. + + + + + Minimum number of milliseconds the input is delayed before it is played back. + + + + + Default percentage by which the delay time is modulated by the low-frequency oscillator (LFO), in hundredths of a percentage point. + + + + + Maximum percentage by which the delay time is modulated by the low-frequency oscillator (LFO), in hundredths of a percentage point. + + + + + Minimum percentage by which the delay time is modulated by the low-frequency oscillator (LFO), in hundredths of a percentage point. + + + + + Default percentage of output signal to feed back into the effect's input. + + + + + Maximum percentage of output signal to feed back into the effect's input. + + + + + Minimum percentage of output signal to feed back into the effect's input. + + + + + Default frequency of the LFO(low-frequency oscillator). + + + + + Maximum frequency of the LFO(low-frequency oscillator). + + + + + Minimum frequency of the LFO(low-frequency oscillator). + + + + + Positive 180 phase differential between left and right LFOs. + + + + + Positive 90 phase differential between left and right LFOs. + + + + + Default phase differential between left and right LFOs. + + + + + Maximum phase differential between left and right LFOs. + + + + + Minimum phase differential between left and right LFOs. + + + + + Negative 180 phase differential between left and right LFOs. + + + + + Negative 90 phase differential between left and right LFOs. + + + + + Zero phase differential between left and right LFOs. + + + + + Default waveform shape of the LFO. By default, the waveform is a sine. + + + + + Sine waveform shape of the LFO. By default, the waveform is a sine. + + + + + Triangular waveform shape of the LFO. By default, the waveform is a sine. + + + + + Default ratio of wet (processed) signal to dry (unprocessed) signal. + + + + + Maximum ratio of wet (processed) signal to dry (unprocessed) signal. + + + + + Minimum ratio of wet (processed) signal to dry (unprocessed) signal. + + + + + Initializes a new instance of the class. + + The native pointer. + + + + The SetAllParameters method sets the flange parameters of a buffer. + + Address of a structure that specifies the effect parameters. + No documentation. + HRESULT IDirectSoundFXFlanger::SetAllParameters([In] LPCDSFXFlanger pcDsFxFlanger) + + + + The GetAllParameters method retrieves the flange parameters of a buffer. + + Address of a structure that receives the effect parameters. + No documentation. + HRESULT IDirectSoundFXFlanger::GetAllParameters([Out] LPDSFXFlanger pDsFxFlanger) + + + + The GetAllParameters method retrieves the flange parameters of a buffer. + + HRESULT IDirectSoundFXFlanger::GetAllParameters([Out] LPDSFXFlanger pDsFxFlanger) + + + + No documentation. + + IDirectSoundFullDuplex + + + + Initializes a new instance of the class. + + + + + + + + + + + + + Initializes a new instance of the class. + + The native pointer. + + + + No documentation. + + IDirectSoundFXGargle + + + + Default rate of modulation, in Hertz. + + + + + Maximum rate of modulation, in Hertz. + + + + + Minimum rate of modulation, in Hertz. + + + + + Default shape of the modulation waveform. + + + + + Square shape of the modulation waveform. + + + + + Triangular shape of the modulation waveform. + + + + + Initializes a new instance of the class. + + The native pointer. + + + + The SetAllParameters method sets the amplitude modulation parameters of a buffer. + + Address of a structure that specifies the effect parameters. + No documentation. + HRESULT IDirectSoundFXGargle::SetAllParameters([In] LPCDSFXGargle pcDsFxGargle) + + + + The GetAllParameters method retrieves the amplitude modulation parameters of a buffer. + + Address of a structure that receives the effect parameters. + No documentation. + HRESULT IDirectSoundFXGargle::GetAllParameters([Out] LPDSFXGargle pDsFxGargle) + + + + The GetAllParameters method retrieves the amplitude modulation parameters of a buffer. + + HRESULT IDirectSoundFXGargle::GetAllParameters([Out] LPDSFXGargle pDsFxGargle) + + + + No documentation. + + DSOUND_ENUM_0 + + + + No documentation. + + DSFXR_PRESENT + + + + No documentation. + + DSFXR_LOCHARDWARE + + + + No documentation. + + DSFXR_LOCSOFTWARE + + + + No documentation. + + DSFXR_UNALLOCATED + + + + No documentation. + + DSFXR_FAILED + + + + No documentation. + + DSFXR_UNKNOWN + + + + No documentation. + + DSFXR_SENDLOOP + + + + No documentation. + + DSOUND_ENUM_1 + + + + No documentation. + + DSFX_I3DL2_MATERIAL_PRESET_SINGLEWINDOW + + + + No documentation. + + DSFX_I3DL2_MATERIAL_PRESET_DOUBLEWINDOW + + + + No documentation. + + DSFX_I3DL2_MATERIAL_PRESET_THINDOOR + + + + No documentation. + + DSFX_I3DL2_MATERIAL_PRESET_THICKDOOR + + + + No documentation. + + DSFX_I3DL2_MATERIAL_PRESET_WOODWALL + + + + No documentation. + + DSFX_I3DL2_MATERIAL_PRESET_BRICKWALL + + + + No documentation. + + DSFX_I3DL2_MATERIAL_PRESET_STONEWALL + + + + No documentation. + + DSFX_I3DL2_MATERIAL_PRESET_CURTAIN + + + + No documentation. + + DSOUND_ENUM_2 + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_DEFAULT + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_GENERIC + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_PADDEDCELL + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_ROOM + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_BATHROOM + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_LIVINGROOM + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_STONEROOM + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_AUDITORIUM + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_CONCERTHALL + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_CAVE + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_ARENA + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_HANGAR + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_CARPETEDHALLWAY + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_HALLWAY + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_STONECORRIDOR + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_ALLEY + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_FOREST + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_CITY + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_MOUNTAINS + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_QUARRY + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_PLAIN + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_PARKINGLOT + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_SEWERPIPE + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_UNDERWATER + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_SMALLROOM + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_MEDIUMROOM + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_LARGEROOM + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_MEDIUMHALL + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_LARGEHALL + + + + No documentation. + + DSFX_I3DL2_ENVIRONMENT_PRESET_PLATE + + + + No documentation. + + DSCAPS_FLAGS + + + + No documentation. + + DSCAPS_PRIMARYMONO + + + + No documentation. + + DSCAPS_PRIMARYSTEREO + + + + No documentation. + + DSCAPS_PRIMARY8BIT + + + + No documentation. + + DSCAPS_PRIMARY16BIT + + + + No documentation. + + DSCAPS_CONTINUOUSRATE + + + + No documentation. + + DSCAPS_EMULDRIVER + + + + No documentation. + + DSCAPS_CERTIFIED + + + + No documentation. + + DSCAPS_SECONDARYMONO + + + + No documentation. + + DSCAPS_SECONDARYSTEREO + + + + No documentation. + + DSCAPS_SECONDARY8BIT + + + + No documentation. + + DSCAPS_SECONDARY16BIT + + + + None. + + None + + + + No documentation. + + DSSPEAKER_ENUM + + + + No documentation. + + DSSPEAKER_DIRECTOUT + + + + No documentation. + + DSSPEAKER_HEADPHONE + + + + No documentation. + + DSSPEAKER_MONO + + + + No documentation. + + DSSPEAKER_QUAD + + + + No documentation. + + DSSPEAKER_STEREO + + + + No documentation. + + DSSPEAKER_SURROUND + + + + No documentation. + + DSSPEAKER_5POINT1 + + + + No documentation. + + DSSPEAKER_7POINT1 + + + + No documentation. + + DSSPEAKER_7POINT1_SURROUND + + + + No documentation. + + DSSPEAKER_5POINT1_SURROUND + + + + No documentation. + + DSSPEAKER_7POINT1_WIDE + + + + No documentation. + + DSSPEAKER_5POINT1_BACK + + + + No documentation. + + DSSPEAKER_GEOMETRY_ENUM + + + + No documentation. + + DSSPEAKER_GEOMETRY_MIN + + + + No documentation. + + DSSPEAKER_GEOMETRY_NARROW + + + + No documentation. + + DSSPEAKER_GEOMETRY_WIDE + + + + No documentation. + + DSSPEAKER_GEOMETRY_MAX + + + + No documentation. + + DSBCAPS_FLAGS + + + + No documentation. + + DSBCAPS_PRIMARYBUFFER + + + + No documentation. + + DSBCAPS_STATIC + + + + No documentation. + + DSBCAPS_LOCHARDWARE + + + + No documentation. + + DSBCAPS_LOCSOFTWARE + + + + No documentation. + + DSBCAPS_CTRL3D + + + + No documentation. + + DSBCAPS_CTRLFREQUENCY + + + + No documentation. + + DSBCAPS_CTRLPAN + + + + No documentation. + + DSBCAPS_CTRLVOLUME + + + + No documentation. + + DSBCAPS_CTRLPOSITIONNOTIFY + + + + No documentation. + + DSBCAPS_CTRLFX + + + + No documentation. + + DSBCAPS_STICKYFOCUS + + + + No documentation. + + DSBCAPS_GLOBALFOCUS + + + + No documentation. + + DSBCAPS_GETCURRENTPOSITION2 + + + + No documentation. + + DSBCAPS_MUTE3DATMAXDISTANCE + + + + No documentation. + + DSBCAPS_LOCDEFER + + + + No documentation. + + DSBCAPS_TRUEPLAYPOSITION + + + + None. + + None + + + + No documentation. + + DSBPLAY_FLAGS + + + + No documentation. + + DSBPLAY_LOOPING + + + + No documentation. + + DSBPLAY_LOCHARDWARE + + + + No documentation. + + DSBPLAY_LOCSOFTWARE + + + + No documentation. + + DSBPLAY_TERMINATEBY_TIME + + + + No documentation. + + DSBPLAY_TERMINATEBY_DISTANCE + + + + No documentation. + + DSBPLAY_TERMINATEBY_PRIORITY + + + + None. + + None + + + + No documentation. + + DSBSTATUS_FLAGS + + + + No documentation. + + DSBSTATUS_PLAYING + + + + No documentation. + + DSBSTATUS_BUFFERLOST + + + + No documentation. + + DSBSTATUS_LOOPING + + + + No documentation. + + DSBSTATUS_LOCHARDWARE + + + + No documentation. + + DSBSTATUS_LOCSOFTWARE + + + + No documentation. + + DSBSTATUS_TERMINATED + + + + None. + + None + + + + No documentation. + + DSCBCAPS_FLAGS + + + + No documentation. + + DSCBCAPS_WAVEMAPPED + + + + No documentation. + + DSCBCAPS_CTRLFX + + + + None. + + None + + + + No documentation. + + DSCCAPS_FLAGS + + + + No documentation. + + DSCCAPS_EMULDRIVER + + + + No documentation. + + DSCCAPS_CERTIFIED + + + + No documentation. + + DSCCAPS_MULTIPLECAPTURE + + + + None. + + None + + + + No documentation. + + DSCBSTATUS_FLAGS + + + + No documentation. + + DSCBSTATUS_CAPTURING + + + + No documentation. + + DSCBSTATUS_LOOPING + + + + None. + + None + + + + No documentation. + + DSBLOCK_ENUM + + + + No documentation. + + DSBLOCK_FROMWRITECURSOR + + + + No documentation. + + DSBLOCK_ENTIREBUFFER + + + + No documentation. + + None + + + + No documentation. + + DSSCL_ENUM + + + + No documentation. + + DSSCL_NORMAL + + + + No documentation. + + DSSCL_PRIORITY + + + + No documentation. + + DSSCL_EXCLUSIVE + + + + No documentation. + + DSSCL_WRITEPRIMARY + + + + No documentation. + + DS3DMODE + + + + No documentation. + + DS3DMODE_NORMAL + + + + No documentation. + + DS3DMODE_HEADRELATIVE + + + + No documentation. + + DS3DMODE_DISABLE + + + + No documentation. + + DSCFX_ENUM + + + + No documentation. + + DSCFX_LOCHARDWARE + + + + No documentation. + + DSCFX_LOCSOFTWARE + + + + No documentation. + + DSCFX_AEC_MODE + + + + No documentation. + + DSCFX_AEC_MODE_PASS_THROUGH + + + + No documentation. + + DSCFX_AEC_MODE_HALF_DUPLEX + + + + No documentation. + + DSCFX_AEC_MODE_FULL_DUPLEX + + + + No documentation. + + DSCFX_AEC_STATUS + + + + No documentation. + + DSCFX_AEC_STATUS_HISTORY_UNINITIALIZED + + + + No documentation. + + DSCFX_AEC_STATUS_HISTORY_CONTINUOUSLY_CONVERGED + + + + No documentation. + + DSCFX_AEC_STATUS_HISTORY_PREVIOUSLY_DIVERGED + + + + No documentation. + + DSCFX_AEC_STATUS_CURRENTLY_CONVERGED + + + + DSound Functions. + + + + Constant None. + + + + Load DLLs and bind functions + + + + + No documentation. + + No documentation. + No documentation. + No documentation. + No documentation. + HRESULT DirectSoundCreate([In, Optional] LPCGUID pcGuidDevice,[Out] LPDIRECTSOUND* ppDS,[None] IUnknown* pUnkOuter) + + + + No documentation. + + No documentation. + No documentation. + No documentation. + HRESULT DirectSoundEnumerateA([In] LPDSENUMCALLBACKA pDSEnumCallback,[In, Optional] void* pContext) + + + + No documentation. + + No documentation. + No documentation. + No documentation. + HRESULT DirectSoundEnumerateW([In] LPDSENUMCALLBACKW pDSEnumCallback,[In, Optional] void* pContext) + + + + No documentation. + + No documentation. + No documentation. + No documentation. + No documentation. + HRESULT DirectSoundCaptureCreate([In, Optional] LPCGUID pcGuidDevice,[Out] LPDIRECTSOUNDCAPTURE* ppDSC,[None] IUnknown* pUnkOuter) + + + + No documentation. + + No documentation. + No documentation. + No documentation. + HRESULT DirectSoundCaptureEnumerateA([In] LPDSENUMCALLBACKA pDSEnumCallback,[In, Optional] void* pContext) + + + + No documentation. + + No documentation. + No documentation. + No documentation. + HRESULT DirectSoundCaptureEnumerateW([In] LPDSENUMCALLBACKW pDSEnumCallback,[In, Optional] void* pContext) + + + + No documentation. + + No documentation. + No documentation. + No documentation. + No documentation. + HRESULT DirectSoundCreate8([In, Optional] LPCGUID pcGuidDevice,[Out] LPDIRECTSOUND8* ppDS8,[None] IUnknown* pUnkOuter) + + + + No documentation. + + No documentation. + No documentation. + No documentation. + No documentation. + HRESULT DirectSoundCaptureCreate8([In, Optional] LPCGUID pcGuidDevice,[Out] LPDIRECTSOUNDCAPTURE8* ppDSC8,[None] IUnknown* pUnkOuter) + + + + The DirectSoundFullDuplexCreate function is documented under a different name. For complete documentation of this function, see {{DirectSoundFullDuplexCreate8}}. + + No documentation. + No documentation. + No documentation. + No documentation. + No documentation. + No documentation. + No documentation. + No documentation. + No documentation. + No documentation. + If the function succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. + HRESULT DirectSoundFullDuplexCreate([In, Optional] LPCGUID pcGuidCaptureDevice,[In, Optional] LPCGUID pcGuidRenderDevice,[In] LPCDSCBUFFERDESC pcDSCBufferDesc,[In] LPCDSBUFFERDESC pcDSBufferDesc,[None] void* hWnd,[None] int dwLevel,[Out] LPDIRECTSOUNDFULLDUPLEX* ppDSFD,[Out] LPDIRECTSOUNDCAPTUREBUFFER8* ppDSCBuffer8,[Out] LPDIRECTSOUNDBUFFER8* ppDSBuffer8,[None] IUnknown* pUnkOuter) + + + + The GetDeviceId method gets the device identifier of the device that is represented by the device-topology object. + + + The device identifier obtained from this method can be used as an input parameter to the {{IMMDeviceEnumerator::GetDevice}} method. For a code example that uses the GetDeviceId method, see {{Using the IKsControl Interface to Access Audio Properties}}. + + Pointer to a reference variable into which the method writes the address of a null-terminated, wide-character string that contains the device identifier. The method allocates the storage for the string. The caller is responsible for freeing the storage, when it is no longer needed, by calling the CoTaskMemFree function. If the GetDeviceId call fails, *ppwstrDeviceId is NULL. For information about CoTaskMemFree, see the Windows SDK documentation. + No documentation. + If the method succeeds, it returns S_OK. If it fails, possible return codes include, but are not limited to, the values shown in the following table. Return codeDescription D_POINTER Pointer ppwstrDeviceId is NULL. E_OUTOFMEMORY Out of memory. ? + HRESULT GetDeviceID([In, Optional] LPCGUID pGuidSrc,[Out] LPGUID pGuidDest) + + + + CaptureEffectGuid Functions. + + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + + SoundEffectGuid Functions. + + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + + DirectSound3DAlgorithmGuid Functions. + + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + + No documentation. + + IDirectSoundBuffer + + + + Initializes a new instance of the class. + + The native pointer. + + + + The GetCaps method retrieves the capabilities of the buffer object. + + Address of a structure to contain the capabilities of this sound buffer. + No documentation. + HRESULT IDirectSoundBuffer::GetCaps([Out] LPDSBCAPS pDSBufferCaps) + + + + The GetCurrentPosition method retrieves the position of the play and write cursors in the sound buffer. + + Address of a variable that receives the offset, in bytes, of the play cursor. This parameter can be NULL if the value is not wanted. + Address of a variable that receives the offset, in bytes, of the write cursor. This parameter can be NULL if the value is not wanted. + No documentation. + HRESULT IDirectSoundBuffer::GetCurrentPosition([Out, Optional] int* pdwCurrentPlayCursor,[Out, Optional] int* pdwCurrentWriteCursor) + + + + The GetFormat method retrieves a description of the format of the sound data in the buffer, or the buffer size needed to retrieve the format description. + + Address of a or structure that receives a description of the sound data in the buffer. To retrieve the buffer size needed to contain the format description, specify NULL. In this case the variable at pdwSizeWritten receives the size of the structure needed to receive the data. + Size, in bytes, of the structure at pwfxFormat. If pwfxFormat is not NULL, this value must be equal to or greater than the size of the expected data. + Address of a variable that receives the number of bytes written to the structure at pwfxFormat. This parameter can be NULL. + No documentation. + HRESULT IDirectSoundBuffer::GetFormat([Out, Buffer, Optional] WAVEFORMATEX* pwfxFormat,[None] int dwSizeAllocated,[Out, Optional] int* pdwSizeWritten) + + + + The GetVolume method retrieves the attenuation of the sound. + + Address of a variable that receives the attenuation, in hundredths of a decibel. + No documentation. + HRESULT IDirectSoundBuffer::GetVolume([Out] int* plVolume) + + + + The GetPan method retrieves the relative volume of the left and right audio channels. + + Address of a variable that receives the relative volume, in hundredths of a decibel. + No documentation. + HRESULT IDirectSoundBuffer::GetPan([Out] int* plPan) + + + + The GetFrequency method retrieves the frequency, in samples per second, at which the buffer is playing. + + Address of a variable that receives the frequency at which the audio buffer is being played, in hertz. + No documentation. + HRESULT IDirectSoundBuffer::GetFrequency([Out] int* pdwFrequency) + + + + The GetStatus method retrieves the status of the sound buffer. + + Address of a variable that receives the status of the sound buffer. The status can be a combination of the following flags: ValueDescription DSBSTATUS_BUFFERLOSTThe buffer is lost and must be restored before it can be played or locked. DSBSTATUS_LOOPINGThe buffer is being looped. If this value is not set, the buffer will stop when it reaches the end of the sound data. This value is returned only in combination with DSBSTATUS_PLAYING. DSBSTATUS_PLAYINGThe buffer is playing. If this value is not set, the buffer is stopped. DSBSTATUS_LOCSOFTWAREThe buffer is playing in software. Set only for buffers created with the DSBCAPS_LOCDEFER flag. DSBSTATUS_LOCHARDWAREThe buffer is playing in hardware. Set only for buffers created with the DSBCAPS_LOCDEFER flag. DSBSTATUS_TERMINATEDThe buffer was prematurely terminated by the voice manager and is not playing. Set only for buffers created with the DSBCAPS_LOCDEFER flag. + No documentation. + HRESULT IDirectSoundBuffer::GetStatus([Out] int* pdwStatus) + + + + The Initialize method initializes a sound buffer object if it has not yet been initialized. + + Address of the device object associated with this buffer. + Address of a structure that contains the values used to initialize this sound buffer. + No documentation. + HRESULT IDirectSoundBuffer::Initialize([In] LPDIRECTSOUND pDirectSound,[In] LPCDSBUFFERDESC pcDSBufferDesc) + + + + The Lock method readies all or part of the buffer for a data write and returns references to which data can be written. + + Offset, in bytes, from the start of the buffer to the point where the lock begins. This parameter is ignored if DSBLOCK_FROMWRITECURSOR is specified in the dwFlags parameter. + Size, in bytes, of the portion of the buffer to lock. The buffer is conceptually circular, so this number can exceed the number of bytes between dwOffset and the end of the buffer. + Address of a variable that receives a reference to the first locked part of the buffer. + Address of a variable that receives the number of bytes in the block at ppvAudioPtr1. If this value is less than dwBytes, the lock has wrapped and ppvAudioPtr2 points to a second block of data at the beginning of the buffer. + Address of a variable that receives a reference to the second locked part of the capture buffer. If NULL is returned, the ppvAudioPtr1 parameter points to the entire locked portion of the capture buffer. + Address of a variable that receives the number of bytes in the block at ppvAudioPtr2. If ppvAudioPtr2 is NULL, this value is zero. + Flags modifying the lock event. The following flags are defined: ValueDescription DSBLOCK_FROMWRITECURSORStart the lock at the write cursor. The dwOffset parameter is ignored. DSBLOCK_ENTIREBUFFERLock the entire buffer. The dwBytes parameter is ignored. + No documentation. + HRESULT IDirectSoundBuffer::Lock([None] int dwOffset,[None] int dwBytes,[Out] void** ppvAudioPtr1,[Out] int* pdwAudioBytes1,[Out] void** ppvAudioPtr2,[Out, Optional] int* pdwAudioBytes2,[None] DSBLOCK_ENUM dwFlags) + + + + The Play method causes the sound buffer to play, starting at the play cursor. + + Reserved. Must be 0. + Priority for the sound, used by the voice manager when assigning hardware mixing resources. The lowest priority is 0, and the highest priority is 0xFFFFFFFF. If the buffer was not created with the DSBCAPS_LOCDEFER flag, this value must be 0. + Flags specifying how to play the buffer. The following flags are defined: Looping flag ValueDescription DSBPLAY_LOOPINGAfter the end of the audio buffer is reached, play restarts at the beginning of the buffer. Play continues until explicitly stopped. This flag must be set when playing a primary buffer. Voice allocation flags The voice allocation flags are valid only for buffers created with the DSBCAPS_LOCDEFER flag. One of the following flags can be used to force the processing of the sound into hardware or software. If neither DBSPLAY_LOCHARDWARE nor DBSPLAY_LOCSOFTWARE is set, the sound is played in either software or hardware, depending on the availability of resources at the time the method is called. See Remarks. ValueDescription DSBPLAY_LOCHARDWAREPlay this voice in a hardware buffer only. If the hardware has no available voices and no voice management flags are set, the call to IDirectSoundBuffer8::Play fails. This flag cannot be combined with DSBPLAY_LOCSOFTWARE. DSBPLAY_LOCSOFTWAREPlay this voice in a software buffer only. This flag cannot be combined with DSBPLAY_LOCHARDWARE or any voice management flag. Voice management flags The voice management flags are valid only for buffers created with the DSBCAPS_LOCDEFER flag, and are used for sounds that are to play in hardware. These flags enable hardware resources that are already in use to be yielded to the current sound. Only buffers created with the DSBCAPS_LOCDEFER flag are candidates for premature termination. See Remarks. ValueDescription DSBPLAY_TERMINATEBY_TIMEIf the hardware has no available voices, a currently playing nonlooping buffer will be stopped to make room for the new buffer. The buffer prematurely terminated is the one with the least time left to play. DSBPLAY_TERMINATEBY_DISTANCEIf the hardware has no available voices, a currently playing buffer will be stopped to make room for the new buffer. The buffer prematurely terminated will be selected from buffers that have the buffer's DSBCAPS_ MUTE3DATMAXDISTANCE flag set and are beyond their maximum distance. If there are no such buffers, the method fails. DSBPLAY_TERMINATEBY_PRIORITYIf the hardware has no available voices, a currently playing buffer will be stopped to make room for the new buffer. The buffer prematurely terminated will be the one with the lowest priority as set by the dwPriority parameter passed to IDirectSoundBuffer8::Play for the buffer. + No documentation. + HRESULT IDirectSoundBuffer::Play([None] int dwReserved1,[None] int dwPriority,[None] DSBPLAY_FLAGS dwFlags) + + + + The SetCurrentPosition method sets the position of the play cursor, which is the point at which the next byte of data is read from the buffer. + + Offset of the play cursor, in bytes, from the beginning of the buffer. + No documentation. + HRESULT IDirectSoundBuffer::SetCurrentPosition([None] int dwNewPosition) + + + + The SetFormat method sets the format of the primary buffer. Whenever this application has the input focus, DirectSound will set the primary buffer to the specified format. + + Address of a structure that describes the new format for the primary sound buffer. + No documentation. + HRESULT IDirectSoundBuffer::SetFormat([In] LPCWAVEFORMATEX pcfxFormat) + + + + The SetVolume method sets the attenuation of the sound. + + Attenuation, in hundredths of a decibel (dB). + No documentation. + HRESULT IDirectSoundBuffer::SetVolume([None] int lVolume) + + + + The SetPan method sets the relative volume of the left and right channels. + + Relative volume between the left and right channels. + No documentation. + HRESULT IDirectSoundBuffer::SetPan([None] int lPan) + + + + The SetFrequency method sets the frequency at which the audio samples are played. + + Frequency, in hertz (Hz), at which to play the audio samples. A value of DSBFREQUENCY_ORIGINAL resets the frequency to the default value of the buffer format. + No documentation. + HRESULT IDirectSoundBuffer::SetFrequency([None] int dwFrequency) + + + + The Stop method causes the sound buffer to stop playing. + + No documentation. + HRESULT IDirectSoundBuffer::Stop() + + + + The Unlock method releases a locked sound buffer. + + Address of the value retrieved in the ppvAudioPtr1 parameter of the {{Lock}} method. + Number of bytes written to the portion of the buffer at pvAudioPtr1. See Remarks. + Address of the value retrieved in the ppvAudioPtr2 parameter of the IDirectSoundBuffer8::Lock method. + Number of bytes written to the portion of the buffer at pvAudioPtr2. See Remarks. + No documentation. + HRESULT IDirectSoundBuffer::Unlock([In, Buffer] void* pvAudioPtr1,[None] int dwAudioBytes1,[In, Buffer, Optional] void* pvAudioPtr2,[None] int dwAudioBytes2) + + + + The Restore method restores the memory allocation for a lost sound buffer. + + No documentation. + HRESULT IDirectSoundBuffer::Restore() + + + HRESULT IDirectSoundBuffer::Play([None] int dwReserved1,[None] int dwPriority,[None] int dwFlags) + + + + The Lock method readies all or part of the buffer for a data write and returns pointers to which data can be written. + + Offset, in bytes, from the start of the buffer to the point where the lock begins. This parameter is ignored if DSBLOCK_FROMWRITECURSOR is specified in the dwFlags parameter. + Size, in bytes, of the portion of the buffer to lock. The buffer is conceptually circular, so this number can exceed the number of bytes between dwOffset and the end of the buffer. + Flags modifying the lock event. The following flags are defined: ValueDescription DSBLOCK_FROMWRITECURSORStart the lock at the write cursor. The dwOffset parameter is ignored. DSBLOCK_ENTIREBUFFERLock the entire buffer. The dwBytes parameter is ignored. + Address of a variable that receives a pointer to the second locked part of the capture buffer. If NULL is returned, the ppvAudioPtr1 parameter points to the entire locked portion of the capture buffer. + Address of a variable that receives a pointer to the first locked part of the buffer. + HRESULT IDirectSoundBuffer::Lock([None] int dwOffset,[None] int dwBytes,[Out] void** ppvAudioPtr1,[Out] int* pdwAudioBytes1,[Out] void** ppvAudioPtr2,[Out, Optional] int* pdwAudioBytes2,[None] int dwFlags) + + + + The Unlock method releases a locked sound buffer. + + Address of the value retrieved in the ppvAudioPtr1 parameter of the {{Lock}} method. + Address of the value retrieved in the ppvAudioPtr2 parameter of the IDirectSoundBuffer8::Lock method. + No documentation. + HRESULT IDirectSoundBuffer::Unlock([In, Buffer] void* pvAudioPtr1,[None] int dwAudioBytes1,[In, Buffer, Optional] void* pvAudioPtr2,[None] int dwAudioBytes2) + + + + Writes data to the buffer. + + + The data. + The buffer offset. + The flags. + + + + Writes data to the buffer. + + + The data. + The start index. + The count. + The buffer offset. + The flags. + + + + Sets the notification positions. + + The positions. + + + + + The GetCaps method retrieves the capabilities of the buffer object. + + HRESULT IDirectSoundBuffer::GetCaps([Out] LPDSBCAPS pDSBufferCaps) + + + + The GetVolume method retrieves the attenuation of the sound. + + HRESULT IDirectSoundBuffer::GetVolume([Out] int* plVolume) + + + + The GetPan method retrieves the relative volume of the left and right audio channels. + + HRESULT IDirectSoundBuffer::GetPan([Out] int* plPan) + + + + The GetFrequency method retrieves the frequency, in samples per second, at which the buffer is playing. + + HRESULT IDirectSoundBuffer::GetFrequency([Out] int* pdwFrequency) + + + + The GetStatus method retrieves the status of the sound buffer. + + HRESULT IDirectSoundBuffer::GetStatus([Out] int* pdwStatus) + + + + The SetCurrentPosition method sets the position of the play cursor, which is the point at which the next byte of data is read from the buffer. + + HRESULT IDirectSoundBuffer::SetCurrentPosition([None] int dwNewPosition) + + + + The SetFormat method sets the format of the primary buffer. Whenever this application has the input focus, DirectSound will set the primary buffer to the specified format. + + HRESULT IDirectSoundBuffer::SetFormat([In] LPCWAVEFORMATEX pcfxFormat) + + + + No documentation. + + IDirectSoundBuffer8 + + + + Initializes a new instance of the class. + + The native pointer. + + + + The SetFX method enables effects on a buffer. + + Number of elements in the pDSFXDesc and pdwResultCodes arrays. If this value is 0, pDSFXDesc and pdwResultCodes must both be NULL. Set to 0 to remove all effects from the buffer. + Address of an array of structures, of size dwEffectsCount, that specifies the effects wanted on the buffer. Must be NULL if dwEffectsCount is 0. + Address of an array of DWORD elements, of size dwEffectsCount. Each element receives one of the values shown in the following table, indicating the result of the attempt to create the corresponding effect in the pDSFXDesc array. Note This parameter must be NULL if dwEffectsCount is 0, or can be NULL if results are not wanted. ValueDescription DSFXR_LOCHARDWAREEffect is instantiated in hardware. DSFXR_LOCSOFTWAREEffect is instantiated in software. DSFXR_UNALLOCATEDEffect has not yet been assigned to hardware or software. This value is returned if the buffer was created with the DSBCAPS_LOCDEFER flag in . DSFXR_FAILEDNo effect was created because resources weren't available. DSFXR_PRESENTEffect is available but was not created because one of the other effects requested could not be created. If any of the effects requested cannot be created, none of them are, and the call fails. DSFXR_UNKNOWNEffect is not registered on the system, and the method failed as a result. + No documentation. + HRESULT IDirectSoundBuffer8::SetFX([None] int dwEffectsCount,[In, Buffer, Optional] LPDSEFFECTDESC pDSFXDesc,[InOut, Buffer] DSOUND_ENUM_0* pdwResultCodes) + + + + The AcquireResources method allocates resources for a buffer that was created with the DSBCAPS_LOCDEFER flag in the structure. + + Flags specifying how resources are to be allocated for a buffer created with the DSBCAPS_LOCDEFER flag. For a list of values, see the voice management and voice allocation flags for {{Play}}. + Number of elements in the pdwResultFlags array, or 0 if pdwResultCodes is NULL. + Address of an array of DWORD variables that receives information about the effects associated with the buffer. This array must contain one element for each effect that was assigned to the buffer by {{SetFX}}. For each effect, one of the values shown in the following table is returned. Note This parameter can be NULL if result codes are not wanted. ValueDescription DSFXR_LOCHARDWAREEffect is instantiated in hardware. DSFXR_LOCSOFTWAREEffect is instantiated in software. DSFXR_FAILEDNo effect was created because resources weren't available. DSFXR_PRESENTThe effect is available but was not created because the method failed for some other reason. DSFXR_UNKNOWNNo effect was created because the effect isn't registered on the system. + No documentation. + HRESULT IDirectSoundBuffer8::AcquireResources([None] int dwFlags,[None] int dwEffectsCount,[Out, Buffer] int* pdwResultCodes) + + + + The GetObjectInPath method retrieves an interface for an effect object associated with the buffer. + + Unique class identifier of the object being searched for, such as GUID_DSFX_STANDARD_ECHO. Set this parameter to GUID_All_Objects to search for objects of any class. + Index of the object within objects of that class in the path. See Remarks. + Unique identifier of the desired interface. See Remarks. + Address of a variable that receives the desired interface reference. + No documentation. + HRESULT IDirectSoundBuffer8::GetObjectInPath([In] GUID* rguidObject,[None] int dwIndex,[In] GUID* rguidInterface,[Out] void** ppObject) + + + + Initializes a new instance of the class. + + an instance of the + The buffer description. + + + + Retrieves an interface to an effect object associated with the buffer. + + Index of the object within objects of that class in the path. See Remarks. + an effect object associated with the buffer + HRESULT IDirectSoundCaptureBuffer8::GetObjectInPath([In] GUID* rguidObject,[None] int dwIndex,[In] GUID* rguidInterface,[Out] void** ppObject) + + + + Enables effects on a buffer. + + Effects guids + No documentation. + HRESULT IDirectSoundBuffer8::SetFX([None] int dwEffectsCount,[In, Buffer, Optional] LPDSEFFECTDESC pDSFXDesc,[Out, Buffer, Optional] int* pdwResultCodes) + + + + No documentation. + + IDirectSound3DListener + + + + Default distance factor. The default value is (1.0). + + + + + Default Doppler factor. The default value is (1.0). + + + + + Default rolloff factor. The default value is (1.0). + + + + + Maximum distance factor. The default value is (1.0). + + + + + Maximum Doppler factor. The default value is (1.0). + + + + + Maximum rolloff factor. The default value is (1.0). + + + + + Minimum distance factor. The default value is (1.0). + + + + + Minimum Doppler factor. The default value is (1.0). + + + + + Minimum rolloff factor. The default value is (1.0). + + + + + Initializes a new instance of the class. + + The native pointer. + + + + The GetAllParameters method retrieves all 3D parameters of the sound environment and the listener. + + Address of a structure that receives the state of the 3D world and listener. + No documentation. + HRESULT IDirectSound3DListener::GetAllParameters([Out] LPDS3DLISTENER pListener) + + + + The GetDistanceFactor method retrieves the distance factor, which is the number of meters in a vector unit. + + Address of a variable that receives the distance factor value. D3DVALUE is defined as float. + No documentation. + HRESULT IDirectSound3DListener::GetDistanceFactor([Out] D3DVALUE* pflDistanceFactor) + + + + The GetDopplerFactor method retrieves the multiplier for the Doppler effect. + + Address of a variable that receives the Doppler factor value. D3DVALUE is defined as float. + No documentation. + HRESULT IDirectSound3DListener::GetDopplerFactor([Out] D3DVALUE* pflDopplerFactor) + + + + The GetOrientation method retrieves the orientation of the listener's head. + + Address of a structure that receives the listener's front orientation vector. + Address of a D3DVECTOR structure that receives the listener's top orientation vector. + No documentation. + HRESULT IDirectSound3DListener::GetOrientation([Out] D3DVECTOR* pvOrientFront,[Out] D3DVECTOR* pvOrientTop) + + + + The GetPosition method retrieves the listener's position. + + Address of a structure that receives the listener's position vector. + No documentation. + HRESULT IDirectSound3DListener::GetPosition([Out] D3DVECTOR* pvPosition) + + + + The GetRolloffFactor method retrieves the rolloff factor, which determines the rate of attenuation over distance. + + Address of a variable that receives the rolloff factor. D3DVALUE is defined as float. + No documentation. + HRESULT IDirectSound3DListener::GetRolloffFactor([Out] D3DVALUE* pflRolloffFactor) + + + + The GetVelocity method retrieves the listener's velocity. + + Address of a structure that receives the listener's velocity. + No documentation. + HRESULT IDirectSound3DListener::GetVelocity([Out] D3DVECTOR* pvVelocity) + + + + The SetAllParameters method sets all 3D parameters of the sound environment and the listener. + + Address of a structure that contains information describing all 3D listener parameters. + Value that specifies when the setting should be applied. This value must be one of the following: ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DListener::SetAllParameters([In] LPCDS3DLISTENER pcListener,[None] int dwApply) + + + + The SetDistanceFactor method sets the distance factor, which is the number of meters in a vector unit. + + Distance factor. D3DVALUE is defined as float. + Value that specifies when the setting should be applied. This value must be one of the following: ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DListener::SetDistanceFactor([None] D3DVALUE flDistanceFactor,[None] int dwApply) + + + + The SetDopplerFactor method sets the multiplier for the Doppler effect. + + Doppler factor. D3DVALUE is defined as float. + Value that specifies when the setting should be applied. This value must be one of the following: ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DListener::SetDopplerFactor([None] D3DVALUE flDopplerFactor,[None] int dwApply) + + + + The SetOrientation method sets the orientation of the listener's head. + + Value that specifies the x coordinate of the front orientation vector. D3DVALUE is defined as float. + Value that specifies the y coordinate of the front orientation vector. D3DVALUE is defined as float. + Value that specifies the z coordinate of the front orientation vector. D3DVALUE is defined as float. + Value that specifies the x coordinates of the top orientation vector. + Value that specifies the y coordinates of the top orientation vector. + Value that specifies the z coordinates of the top orientation vector. + Value that specifies when the setting should be applied. This value must be one of the following: ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DListener::SetOrientation([None] D3DVALUE xFront,[None] D3DVALUE yFront,[None] D3DVALUE zFront,[None] D3DVALUE xTop,[None] D3DVALUE yTop,[None] D3DVALUE zTop,[None] int dwApply) + + + + The SetPosition method sets the listener's position. + + Value that specifies the x coordinate of the listener's position vector. Note that DirectSound may adjust this value to prevent floating-point overflow. D3DVALUE is defined as float. + Value that specifies the y coordinate of the listener's position vector. Note that DirectSound may adjust this value to prevent floating-point overflow. D3DVALUE is defined as float. + Value that specifies the z coordinate of the listener's position vector. Note that DirectSound may adjust this value to prevent floating-point overflow. D3DVALUE is defined as float. + Value that specifies when the setting should be applied. This value must be one of the following: ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DListener::SetPosition([None] D3DVALUE x,[None] D3DVALUE y,[None] D3DVALUE z,[None] int dwApply) + + + + The SetRolloffFactor method sets the rolloff factor, which determines the rate of attenuation over distance. + + Rolloff factor. D3DVALUE is defined as float. + Value that specifies when the setting should be applied. This value must be one of the following: ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DListener::SetRolloffFactor([None] D3DVALUE flRolloffFactor,[None] int dwApply) + + + + The SetVelocity method sets the listener's velocity. + + Value that specifies the x coordinate of the listener's velocity vector. DirectSound may adjust this value to prevent floating-point overflow. D3DVALUE is defined as float. + Value that specifies the y coordinate of the listener's velocity vector. DirectSound may adjust this value to prevent floating-point overflow. D3DVALUE is defined as float. + Value that specifies the z coordinate of the listener's velocity vector. DirectSound may adjust this value to prevent floating-point overflow. D3DVALUE is defined as float. + Value that specifies when the setting should be applied. This value must be one of the following: ValueDescription DS3D_DEFERREDSettings are not applied until the application calls the {{CommitDeferredSettings}} method. This allows the application to change several settings and generate a single recalculation. DS3D_IMMEDIATESettings are applied immediately, causing the system to recalculate the 3D coordinates for all 3D sound buffers. + No documentation. + HRESULT IDirectSound3DListener::SetVelocity([None] D3DVALUE x,[None] D3DVALUE y,[None] D3DVALUE z,[None] int dwApply) + + + + The CommitDeferredSettings method commits any deferred settings made since the last call to this method. + + No documentation. + HRESULT IDirectSound3DListener::CommitDeferredSettings() + + + + Initializes a new instance of the class + with a previously created sound buffer. + + The SlimDX::DirectSound::SoundBuffer object. + + + + Determines if settings are set immediately or deferred. + + + + + Gets or sets the distance factor, which is the number of meters in a vector unit. + + + + + Gets or sets the multiplier for the Doppler effect. + + + + + Describes the listener's front orientation. + + + + + Gets or sets the listener's position. + + + + + Gets or sets the rolloff factor, which determines the rate of attenuation over distance. + + + + + Describes the listener's top orientation. + + + + + Gets or sets the listener's velocity. + + + + + No documentation. + + IDirectSoundNotify + + + + Initializes a new instance of the class. + + The native pointer. + + + + The SetNotificationPositions method sets the notification positions. During capture or playback, whenever the read or play cursor reaches one of the specified offsets, the associated event is signaled. + + Number of structures. + Pointer to an array of DSBPOSITIONNOTIFY structures (the maximum array size is DSBNOTIFICATIONS_MAX). + No documentation. + HRESULT IDirectSoundNotify::SetNotificationPositions([None] int dwPositionNotifies,[In, Buffer] LPCDSBPOSITIONNOTIFY pcPositionNotifies) + + + + No documentation. + + IDirectSoundFXParamEq + + + + Default bandwidth, in semitones. + + + + + Maximum bandwidth, in semitones. + + + + + Minimum bandwidth, in semitones. + + + + + Default center frequency, in hertz. + + + + + Maximum center frequency, in hertz. + + + + + Minimum center frequency, in hertz. + + + + + Default gain. + + + + + Maximum gain. + + + + + Minimum gain. + + + + + Initializes a new instance of the class. + + The native pointer. + + + + The SetAllParameters method sets the parametric equalizer parameters of a buffer. + + Address of a structure that specifies the effect parameters. + No documentation. + HRESULT IDirectSoundFXParamEq::SetAllParameters([In] LPCDSFXParamEq pcDsFxParamEq) + + + + The GetAllParameters method retrieves the parametric equalizer parameters of a buffer. + + Address of a structure that receives the effect parameters. + No documentation. + HRESULT IDirectSoundFXParamEq::GetAllParameters([Out] LPDSFXParamEq pDsFxParamEq) + + + + The GetAllParameters method retrieves the parametric equalizer parameters of a buffer. + + HRESULT IDirectSoundFXParamEq::GetAllParameters([Out] LPDSFXParamEq pDsFxParamEq) + + + + No documentation. + + IDirectSoundFXI3DL2Reverb + + + + Default ratio of the decay time at high frequencies to the decay time at low frequencies. + + + + + Maximum ratio of the decay time at high frequencies to the decay time at low frequencies. + + + + + Minimum ratio of the decay time at high frequencies to the decay time at low frequencies. + + + + + Default decay time, in seconds. + + + + + Maximum decay time, in seconds. + + + + + Minimum decay time, in seconds. + + + + + Default modal density in the late reverberation decay, in percent. + + + + + Maximum modal density in the late reverberation decay, in percent. + + + + + Minimum modal density in the late reverberation decay, in percent. + + + + + Default echo density in the late reverberation decay, in percent. + + + + + Maximum echo density in the late reverberation decay, in percent. + + + + + Minimum echo density in the late reverberation decay, in percent. + + + + + Default reference high frequency, in hertz. + + + + + Maximum reference high frequency, in hertz. + + + + + Minimum reference high frequency, in hertz. + + + + + Default attenuation of early reflections relative to Room, in mB. + + + + + Default delay time of the first reflection relative to the direct path, in seconds. + + + + + Maximum delay time of the first reflection relative to the direct path, in seconds. + + + + + Minimum delay time of the first reflection relative to the direct path, in seconds. + + + + + Maximum attenuation of early reflections relative to Room, in mB. + + + + + Minimum attenuation of early reflections relative to Room, in mB. + + + + + Default attenuation of late reverberation relative to Room, in mB. + + + + + Default time limit between the early reflections and the late reverberation relative to the time of the first reflection, in seconds. + + + + + Maximum time limit between the early reflections and the late reverberation relative to the time of the first reflection, in seconds. + + + + + Minimum time limit between the early reflections and the late reverberation relative to the time of the first reflection, in seconds. + + + + + Maximum attenuation of late reverberation relative to Room, in mB. + + + + + Minimum attenuation of late reverberation relative to Room, in mB. + + + + + Default attenuation of the room effect, in millibels (mB). + + + + + Default attenuation of the room high-frequency effect, in mB. + + + + + Maximum attenuation of the room high-frequency effect, in mB. + + + + + Minimum attenuation of the room high-frequency effect, in mB. + + + + + Maximum attenuation of the room effect, in millibels (mB). + + + + + Minimum attenuation of the room effect, in millibels (mB). + + + + + Default rolloff factor for the reflected signals. The rolloff factor for the direct path is controlled by the DirectSound listener. + + + + + Maximum rolloff factor for the reflected signals. The rolloff factor for the direct path is controlled by the DirectSound listener. + + + + + Minimum rolloff factor for the reflected signals. The rolloff factor for the direct path is controlled by the DirectSound listener. + + + + + Initializes a new instance of the class. + + The native pointer. + + + + No documentation. + + No documentation. + No documentation. + HRESULT IDirectSoundFXI3DL2Reverb::SetAllParameters([In] LPCDSFXI3DL2Reverb pcDsFxI3DL2Reverb) + + + + No documentation. + + No documentation. + No documentation. + HRESULT IDirectSoundFXI3DL2Reverb::GetAllParameters([Out] LPDSFXI3DL2Reverb pDsFxI3DL2Reverb) + + + + No documentation. + + No documentation. + No documentation. + HRESULT IDirectSoundFXI3DL2Reverb::SetPreset([None] int dwPreset) + + + + No documentation. + + No documentation. + No documentation. + HRESULT IDirectSoundFXI3DL2Reverb::GetPreset([Out] int* pdwPreset) + + + + No documentation. + + No documentation. + No documentation. + HRESULT IDirectSoundFXI3DL2Reverb::SetQuality([None] int lQuality) + + + + No documentation. + + No documentation. + No documentation. + HRESULT IDirectSoundFXI3DL2Reverb::GetQuality([Out] int* plQuality) + + + + No documentation. + + HRESULT IDirectSoundFXI3DL2Reverb::GetAllParameters([Out] LPDSFXI3DL2Reverb pDsFxI3DL2Reverb) + + + + No documentation. + + HRESULT IDirectSoundFXI3DL2Reverb::GetPreset([Out] int* pdwPreset) + + + + No documentation. + + HRESULT IDirectSoundFXI3DL2Reverb::GetQuality([Out] int* plQuality) + + + + No documentation. + + IDirectSoundFXWavesReverb + + + + Default high-frequency reverb time ratio. + + + + + Maximum high-frequency reverb time ratio. + + + + + Minimum high-frequency reverb time ratio. + + + + + Default input gain of signal, in decibels (dB). + + + + + Maximum input gain of signal, in decibels (dB). + + + + + Minimum input gain of signal, in decibels (dB). + + + + + Default reverb mix, in dB. + + + + + Maximum reverb mix, in dB. + + + + + Minimum reverb mix, in dB. + + + + + Default reverb time, in milliseconds. + + + + + Maximum reverb time, in milliseconds. + + + + + Minimum reverb time, in milliseconds. + + + + + Initializes a new instance of the class. + + The native pointer. + + + + The SetAllParameters method sets the music reverberation parameters of a buffer. + + Address of a structure that specifies the effect parameters. + No documentation. + HRESULT IDirectSoundFXWavesReverb::SetAllParameters([In] LPCDSFXWavesReverb pcDsFxWavesReverb) + + + + The GetAllParameters method retrieves the music reverberation parameters of a buffer. + + Address of a structure that receives the effect parameters. + No documentation. + HRESULT IDirectSoundFXWavesReverb::GetAllParameters([Out] LPDSFXWavesReverb pDsFxWavesReverb) + + + + The GetAllParameters method retrieves the music reverberation parameters of a buffer. + + HRESULT IDirectSoundFXWavesReverb::GetAllParameters([Out] LPDSFXWavesReverb pDsFxWavesReverb) + + + + No documentation. + + IDirectSoundCaptureFXAec + + + + Initializes a new instance of the class. + + The native pointer. + + + + The SetAllParameters method sets the acoustic echo cancellation parameters of a buffer. + + Address of a structure that specifies the effect parameters. + No documentation. + HRESULT IDirectSoundCaptureFXAec::SetAllParameters([In] LPCDSCFXAec pDscFxAec) + + + + The GetAllParameters method retrieves the acoustic echo cancellation parameters of a buffer. + + Address of a structure that receives the effect parameters. + No documentation. + HRESULT IDirectSoundCaptureFXAec::GetAllParameters([Out] LPDSCFXAec pDscFxAec) + + + + The IDirectSoundCaptureFXAec8::GetStatus method retrieves the status of the effect. + + Address of a DWORD variable to receive the status. The following flags are defined. See Remarks. ConstantValue DSCFX_AEC_STATUS_HISTORY_UNINITIALIZED0x0 DSCFX_AEC_STATUS_HISTORY_CONTINUOUSLY_CONVERGED0x1 DSCFX_AEC_STATUS_HISTORY_PREVIOUSLY_DIVERGED0x2 DSCFX_AEC_STATUS_CURRENTLY_CONVERGED0x8 + No documentation. + HRESULT IDirectSoundCaptureFXAec::GetStatus([Out] DSCFX_AEC_STATUS* pdwStatus) + + + + The IDirectSoundCaptureFXAec8::Reset method resets the effect to its initial state. + + No documentation. + HRESULT IDirectSoundCaptureFXAec::Reset() + + + + The GetAllParameters method retrieves the acoustic echo cancellation parameters of a buffer. + + HRESULT IDirectSoundCaptureFXAec::GetAllParameters([Out] LPDSCFXAec pDscFxAec) + + + + The IDirectSoundCaptureFXAec8::GetStatus method retrieves the status of the effect. + + HRESULT IDirectSoundCaptureFXAec::GetStatus([Out] DSCFX_AEC_STATUS* pdwStatus) + + + + No documentation. + + IDirectSoundCaptureFXNoiseSuppress + + + + Initializes a new instance of the class. + + The native pointer. + + + + The SetAllParameters method sets the noise suppression parameters of a buffer. + + Address of a structure that specifies the effect parameters. + No documentation. + HRESULT IDirectSoundCaptureFXNoiseSuppress::SetAllParameters([In] LPCDSCFXNoiseSuppress pcDscFxNoiseSuppress) + + + + The GetAllParameters method retrieves the noise suppression parameters of a buffer. + + Address of a structure that receives the effect parameters. + No documentation. + HRESULT IDirectSoundCaptureFXNoiseSuppress::GetAllParameters([Out] LPDSCFXNoiseSuppress pDscFxNoiseSuppress) + + + + The IDirectSoundCaptureFXNoiseSuppress8::Reset method resets the effect to its initial state. + + No documentation. + HRESULT IDirectSoundCaptureFXNoiseSuppress::Reset() + + + + The GetAllParameters method retrieves the noise suppression parameters of a buffer. + + HRESULT IDirectSoundCaptureFXNoiseSuppress::GetAllParameters([Out] LPDSCFXNoiseSuppress pDscFxNoiseSuppress) + + + + Gets or sets he noise suppression parameters of a buffer. + + + + + The DSBCAPS structure describes the capabilities of a DirectSound buffer object. It is used by the {{IDirectSoundBuffer8::GetCaps}} method. + + DSBCAPS + + + + Size of the structure, in bytes. This member must be initialized before the structure is used. + + int dwSize + + + + Flags that specify buffer-object capabilities. Use one or more of the values shown in the following table. Value + Description + DSBCAPS_CTRL3D + The buffer has 3D control capability. + DSBCAPS_CTRLFREQUENCY + The buffer has frequency control capability. + DSBCAPS_CTRLFX + The buffer supports effects processing. + DSBCAPS_CTRLPAN + The buffer has pan control capability. + DSBCAPS_CTRLVOLUME + The buffer has volume control capability. + DSBCAPS_CTRLPOSITIONNOTIFY + The buffer has position notification capability. See the Remarks for . + DSBCAPS_GETCURRENTPOSITION2 + The buffer uses the new behavior of the play cursor when {{IDirectSoundBuffer8::GetCurrentPosition}} is called. In the first version of DirectSound, the play cursor was significantly ahead of the actual playing sound on emulated sound cards; it was directly behind the write cursor. Now, if the DSBCAPS_GETCURRENTPOSITION2 flag is specified, the application can get a more accurate play cursor. If this flag is not specified, the old behavior is preserved for compatibility. This flag affects only emulated devices; if a DirectSound driver is present, the play cursor is accurate for DirectSound in all versions of DirectX. + DSBCAPS_GLOBALFOCUS + The buffer is a global sound buffer. With this flag set, an application using DirectSound can continue to play its buffers if the user switches focus to another application, even if the new application uses DirectSound. The one exception is if you switch focus to a DirectSound application that uses the DSSCL_WRITEPRIMARY flag for its cooperative level. In this case, the global sounds from other applications will not be audible. + DSBCAPS_LOCDEFER + The buffer can be assigned to a hardware or software resource at play time, or when is called. + DSBCAPS_LOCHARDWARE + The buffer uses hardware mixing. + DSBCAPS_LOCSOFTWARE + The buffer is in software memory and uses software mixing. + DSBCAPS_MUTE3DATMAXDISTANCE + The sound is reduced to silence at the maximum distance. The buffer will stop playing when the maximum distance is exceeded, so that processor time is not wasted. Applies only to software buffers. + DSBCAPS_PRIMARYBUFFER + The buffer is a primary buffer. + DSBCAPS_STATIC + The buffer is in on-board hardware memory. + DSBCAPS_STICKYFOCUS + The buffer has sticky focus. If the user switches to another application not using DirectSound, the buffer is still audible. However, if the user switches to another DirectSound application, the buffer is muted. + DSBCAPS_TRUEPLAYPOSITION + Force {{IDirectSoundBuffer8::GetCurrentPosition}} to return the buffer's true play position. This flag is only valid in Windows Vista. + + + DSBCAPS_FLAGS dwFlags + + + + Size of this buffer, in bytes. + + int dwBufferBytes + + + + The rate, in kilobytes per second, at which data is transferred to the buffer memory when {{IDirectSoundBuffer8::Unlock}} is called. High-performance applications can use this value to determine the time required for IDirectSoundBuffer8::Unlock to execute. For software buffers located in system memory, the rate will be very high because no processing is required. For hardware buffers, the rate might be slower because the buffer might have to be downloaded to the sound card, which might have a limited transfer rate. + + int dwUnlockTransferRate + + + + The processing overhead as a percentage of main processor cycles needed to mix this sound buffer. For hardware buffers, this member will be zero because the mixing is performed by the sound device. For software buffers, this member depends on the buffer format and the speed of the system processor. + + int dwPlayCpuOverhead + + + + Initializes a new instance of the class. + + + + + No documentation. + + DSBUFFERDESC + + + + No documentation. + + int dwSize + + + + No documentation. + + DSBCAPS_FLAGS dwFlags + + + + No documentation. + + int dwBufferBytes + + + + No documentation. + + int dwReserved + + + + No documentation. + + WAVEFORMATEX* lpwfxFormat + + + + No documentation. + + GUID guid3DAlgorithm + + + + Initializes a new instance of the class. + + + + + WaveFormat of this sound buffer description + + + + + No documentation. + + DS3DLISTENER + + + + No documentation. + + int dwSize + + + + No documentation. + + D3DVECTOR vPosition + + + + No documentation. + + D3DVECTOR vVelocity + + + + No documentation. + + D3DVECTOR vOrientFront + + + + No documentation. + + D3DVECTOR vOrientTop + + + + No documentation. + + D3DVALUE flDistanceFactor + + + + No documentation. + + D3DVALUE flRolloffFactor + + + + No documentation. + + D3DVALUE flDopplerFactor + + + + Initializes a new instance of the class. + + + + + No documentation. + + DSBPOSITIONNOTIFY + + + + No documentation. + + int dwOffset + + + + No documentation. + + void* hEventNotify + + + + Gets or sets the wait handle. + + The wait handle. + + + + No documentation. + + DSFXGargle + + + + No documentation. + + int dwRateHz + + + + No documentation. + + int dwWaveShape + + + + No documentation. + + DSFXChorus + + + + No documentation. + + float fWetDryMix + + + + No documentation. + + float fDepth + + + + No documentation. + + float fFeedback + + + + No documentation. + + float fFrequency + + + + No documentation. + + int lWaveform + + + + No documentation. + + float fDelay + + + + No documentation. + + int lPhase + + + + No documentation. + + DSFXFlanger + + + + No documentation. + + float fWetDryMix + + + + No documentation. + + float fDepth + + + + No documentation. + + float fFeedback + + + + No documentation. + + float fFrequency + + + + No documentation. + + int lWaveform + + + + No documentation. + + float fDelay + + + + No documentation. + + int lPhase + + + + No documentation. + + DSFXEcho + + + + No documentation. + + float fWetDryMix + + + + No documentation. + + float fFeedback + + + + No documentation. + + float fLeftDelay + + + + No documentation. + + float fRightDelay + + + + No documentation. + + int lPanDelay + + + + No documentation. + + DSFXDistortion + + + + No documentation. + + float fGain + + + + No documentation. + + float fEdge + + + + No documentation. + + float fPostEQCenterFrequency + + + + No documentation. + + float fPostEQBandwidth + + + + No documentation. + + float fPreLowpassCutoff + + + + No documentation. + + DSFXCompressor + + + + No documentation. + + float fGain + + + + No documentation. + + float fAttack + + + + No documentation. + + float fRelease + + + + No documentation. + + float fThreshold + + + + No documentation. + + float fRatio + + + + No documentation. + + float fPredelay + + + + No documentation. + + DSFXParamEq + + + + No documentation. + + float fCenter + + + + No documentation. + + float fBandwidth + + + + No documentation. + + float fGain + + + + No documentation. + + DSFXI3DL2Reverb + + + + No documentation. + + int lRoom + + + + No documentation. + + int lRoomHF + + + + No documentation. + + float flRoomRolloffFactor + + + + No documentation. + + float flDecayTime + + + + No documentation. + + float flDecayHFRatio + + + + No documentation. + + int lReflections + + + + No documentation. + + float flReflectionsDelay + + + + No documentation. + + int lReverb + + + + No documentation. + + float flReverbDelay + + + + No documentation. + + float flDiffusion + + + + No documentation. + + float flDensity + + + + No documentation. + + float flHFReference + + + + No documentation. + + DSFXWavesReverb + + + + No documentation. + + float fInGain + + + + No documentation. + + float fReverbMix + + + + No documentation. + + float fReverbTime + + + + No documentation. + + float fHighFreqRTRatio + + + + No documentation. + + DSCFXAec + + + + No documentation. + + DSCFX_AEC_MODE dwMode + + + + No documentation. + + BOOL fEnable + + + + No documentation. + + BOOL fNoiseFill + + + + No documentation. + + DSCFXNoiseSuppress + + + + No documentation. + + BOOL fEnable + + + + A Primary DirectSound Buffer. + + + + + Initializes a new instance of the class. + + The base PTR. + + + + Initializes a new instance of the class. + + an instance of the + The buffer description. + + + diff --git a/Libs/SharpDX.Error.dll b/Libs/SharpDX.Error.dll new file mode 100644 index 0000000000000000000000000000000000000000..8e57b0b86738a3911fbb15c9f90f640e561d061e GIT binary patch literal 350720 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

Sf}TPtjc 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≺zT%gl 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Ųu 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 X$bo-$*Kltv`-z|ZJGk~AEqVAqcd#Z8 literal 0 HcmV?d00001 diff --git a/Libs/SharpDX.Error.xml b/Libs/SharpDX.Error.xml new file mode 100644 index 0000000..a6d5710 --- /dev/null +++ b/Libs/SharpDX.Error.xml @@ -0,0 +1,43 @@ + + + + SharpDX.Error + + + +

+ ErrorManager helper to get a description from a HRESULT/SharpDX.Result code. + + + + + No instance + + + + + Initialize Map + + + + + Add a message description for a particular code. + + the error code + string representation of the code + description of the error + + + + Returns an error description. + + An error code + a description + + + + Error description holder + + + + diff --git a/Libs/SharpDX.XAPO.dll b/Libs/SharpDX.XAPO.dll new file mode 100644 index 0000000000000000000000000000000000000000..175492aaf806f27929de91227df9834cb0f27fd4 GIT binary patch literal 20480 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 literal 0 HcmV?d00001 diff --git a/Libs/SharpDX.XAPO.xml b/Libs/SharpDX.XAPO.xml new file mode 100644 index 0000000..65ddb4d --- /dev/null +++ b/Libs/SharpDX.XAPO.xml @@ -0,0 +1,970 @@ + + + + SharpDX.XAPO + + + + + Interface that defines an XAPO, allowing it to be used in an XAudio2 effect chain. + + IXAPO + + + + Queries if a specific input format is supported for a given output format. + + Output format. + Input format to check for being supported. + If not NULL, and the input format is not supported for the given output format, ppSupportedInputFormat returns a pointer to the closest input format that is supported. Use {{XAPOFree}} to free the returned structure. + No documentation. + HRESULT IXAPO::IsInputFormatSupported([None] const WAVEFORMATEX* pOutputFormat,[None] const WAVEFORMATEX* pRequestedInputFormat,[Out, Optional] WAVEFORMATEX** ppSupportedInputFormat) + + + + Queries if a specific output format is supported for a given input format. + + [in] Input format. + [in] Output format to check for being supported. + [out] If not NULL and the output format is not supported for the given input format, ppSupportedOutputFormat returns a pointer to the closest output format that is supported. Use {{XAPOFree}} to free the returned structure. + No documentation. + HRESULT IXAPO::IsOutputFormatSupported([None] const WAVEFORMATEX* pInputFormat,[None] const WAVEFORMATEX* pRequestedOutputFormat,[Out, Optional] WAVEFORMATEX** ppSupportedOutputFormat) + + + + Performs any effect-specific initialization. + + Effect-specific initialization parameters, may be NULL if DataByteSize is 0. + No documentation. + HRESULT IXAPO::Initialize([In, Buffer, Optional] const void* pData,[None] UINT32 DataByteSize) + + + + Resets variables dependent on frame history. + + void IXAPO::Reset() + + + + Called by XAudio2 to lock the input and output configurations of an XAPO allowing it to + do any final initialization before {{Process}} is called on the realtime thread. + + Array of input structures.pInputLockedParameters may be NULL if InputLockedParameterCount is 0, otherwise itmust have InputLockedParameterCount elements. + Array of output structures.pOutputLockedParameters may be NULL if OutputLockedParameterCount is 0, otherwise itmust have OutputLockedParameterCount elements. + No documentation. + HRESULT IXAPO::LockForProcess([None] UINT32 InputLockedParameterCount,[In, Buffer, Optional] const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pInputLockedParameters,[None] UINT32 OutputLockedParameterCount,[In, Buffer, Optional] const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pOutputLockedParameters) + + + + Deallocates variables that were allocated with the {{LockForProcess}} method. + + void IXAPO::UnlockForProcess() + + + + Runs the XAPO's digital signal processing (DSP) code on the given input and output buffers. + + [in] Input array of structures. + [in, out] Output array of structures. On input, the value of .ValidFrameCount indicates the number of frames that the XAPO should write to the output buffer. On output, the value of .ValidFrameCount indicates the actual number of frames written. + TRUE to process normally; FALSE to process thru. See Remarks for additional information. + void IXAPO::Process([None] UINT32 InputProcessParameterCount,[In, Buffer, Optional] const XAPO_PROCESS_BUFFER_PARAMETERS* pInputProcessParameters,[None] UINT32 OutputProcessParameterCount,[InOut, Buffer, Optional] XAPO_PROCESS_BUFFER_PARAMETERS* pOutputProcessParameters,[None] BOOL IsEnabled) + + + + Returns the number of input frames required to generate the given number of output frames. + + The number of output frames desired. + No documentation. + UINT32 IXAPO::CalcInputFrames([None] UINT32 OutputFrameCount) + + + + Returns the number of output frames that will be generated from a given number of input frames. + + The number of input frames. + No documentation. + UINT32 IXAPO::CalcOutputFrames([None] UINT32 InputFrameCount) + + + + Returns the registration properties of an XAPO. + + a structure containing theregistration properties the XAPO was created with; use XAPOFree to free thestructure. + HRESULT IXAPO::GetRegistrationProperties([Out] XAPO_REGISTRATION_PROPERTIES** ppRegistrationProperties) + + + + Base AudioProcessor class that implements methods from . This class is + also providing its parameter through a generic. + + type of the parameter for this AudioProcessor + + + + An optional interface that allows an XAPO to use effect-specific parameters. + + IXAPOParameters + + + + Sets effect-specific parameters. + + Effect-specific parameter block. + void IXAPOParameters::SetParameters([In, Buffer] const void* pParameters,[None] UINT32 ParameterByteSize) + + + + Gets the current values for any effect-specific parameters. + + [in, out] Receives an effect-specific parameter block. + void IXAPOParameters::GetParameters([Out, Buffer] void* pParameters,[None] UINT32 ParameterByteSize) + + + + Initializes a new instance of the class. + + + + + Queries if a specific input format is supported for a given output format. + + Output format. + Input format to check for being supported. + If not NULL, and the input format is not supported for the given output format, ppSupportedInputFormat returns a pointer to the closest input format that is supported. Use {{XAPOFree}} to free the returned structure. + No documentation. + HRESULT IXAPO::IsInputFormatSupported([None] const WAVEFORMATEX* pOutputFormat,[None] const WAVEFORMATEX* pRequestedInputFormat,[Out, Optional] WAVEFORMATEX** ppSupportedInputFormat) + + + + Queries if a specific output format is supported for a given input format. + + [in] Input format. + [in] Output format to check for being supported. + [out] If not NULL and the output format is not supported for the given input format, ppSupportedOutputFormat returns a pointer to the closest output format that is supported. Use {{XAPOFree}} to free the returned structure. + No documentation. + HRESULT IXAPO::IsOutputFormatSupported([None] const WAVEFORMATEX* pInputFormat,[None] const WAVEFORMATEX* pRequestedOutputFormat,[Out, Optional] WAVEFORMATEX** ppSupportedOutputFormat) + + + + Performs any effect-specific initialization. + + Effect-specific initialization parameters, may be NULL if DataByteSize is 0. + No documentation. + HRESULT IXAPO::Initialize([In, Buffer, Optional] const void* pData,[None] UINT32 DataByteSize) + + + + Resets variables dependent on frame history. + + void IXAPO::Reset() + + + + Called by XAudio2 to lock the input and output configurations of an XAPO allowing it to + do any final initialization before {{Process}} is called on the realtime thread. + + Array of input structures.pInputLockedParameters may be NULL if InputLockedParameterCount is 0, otherwise itmust have InputLockedParameterCount elements. + Array of output structures.pOutputLockedParameters may be NULL if OutputLockedParameterCount is 0, otherwise itmust have OutputLockedParameterCount elements. + No documentation. + HRESULT IXAPO::LockForProcess([None] UINT32 InputLockedParameterCount,[In, Buffer, Optional] const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pInputLockedParameters,[None] UINT32 OutputLockedParameterCount,[In, Buffer, Optional] const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pOutputLockedParameters) + + + + Deallocates variables that were allocated with the {{LockForProcess}} method. + + void IXAPO::UnlockForProcess() + + + + Runs the XAPO's digital signal processing (DSP) code on the given input and output buffers. + + [in] Input array of structures. + [in, out] Output array of structures. On input, the value of .ValidFrameCount indicates the number of frames that the XAPO should write to the output buffer. On output, the value of .ValidFrameCount indicates the actual number of frames written. + TRUE to process normally; FALSE to process thru. See Remarks for additional information. + void IXAPO::Process([None] UINT32 InputProcessParameterCount,[In, Buffer, Optional] const XAPO_PROCESS_BUFFER_PARAMETERS* pInputProcessParameters,[None] UINT32 OutputProcessParameterCount,[InOut, Buffer, Optional] XAPO_PROCESS_BUFFER_PARAMETERS* pOutputProcessParameters,[None] BOOL IsEnabled) + + + + Returns the number of input frames required to generate the given number of output frames. + + The number of output frames desired. + No documentation. + UINT32 IXAPO::CalcInputFrames([None] UINT32 OutputFrameCount) + + + + Returns the number of output frames that will be generated from a given number of input frames. + + The number of input frames. + No documentation. + UINT32 IXAPO::CalcOutputFrames([None] UINT32 InputFrameCount) + + + + Sets effect-specific parameters. + + Effect-specific parameter block. + void IXAPOParameters::SetParameters([In, Buffer] const void* pParameters,[None] UINT32 ParameterByteSize) + + + + Gets the current values for any effect-specific parameters. + + [in, out] Receives an effect-specific parameter block. + void IXAPOParameters::GetParameters([Out, Buffer] void* pParameters,[None] UINT32 ParameterByteSize) + + + + Return parameters + + + + + Gets the input format locked. + + The input format locked. + + + + Gets the output format locked. + + The output format locked. + + + + Gets the max frame count locked. + + The max frame count locked. + + + + Returns the registration properties of an XAPO. + + a structure containing theregistration properties the XAPO was created with; use XAPOFree to free thestructure. + HRESULT IXAPO::GetRegistrationProperties([Out] XAPO_REGISTRATION_PROPERTIES** ppRegistrationProperties) + + + + Internal AudioProcessorCallback + + IXAPO GUID + + + HRESULT IXAPO::GetRegistrationProperties([Out] XAPO_REGISTRATION_PROPERTIES** ppRegistrationProperties) + + + HRESULT IXAPO::IsInputFormatSupported([None] const WAVEFORMATEX* pOutputFormat,[None] const WAVEFORMATEX* pRequestedInputFormat,[Out, Optional] WAVEFORMATEX** ppSupportedInputFormat) + + + HRESULT IXAPO::IsOutputFormatSupported([None] const WAVEFORMATEX* pInputFormat,[None] const WAVEFORMATEX* pRequestedOutputFormat,[Out, Optional] WAVEFORMATEX** ppSupportedOutputFormat) + + + HRESULT IXAPO::Initialize([In, Buffer, Optional] const void* pData,[None] UINT32 DataByteSize) + + + void IXAPO::Reset() + + + HRESULT IXAPO::LockForProcess([None] UINT32 InputLockedParameterCount,[In, Buffer, Optional] const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pInputLockedParameters,[None] UINT32 OutputLockedParameterCount,[In, Buffer, Optional] const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pOutputLockedParameters) + + + + Deallocates variables that were allocated with the {{LockForProcess}} method. + + void IXAPO::UnlockForProcess() + + + void IXAPO::Process([None] UINT32 InputProcessParameterCount,[In, Buffer, Optional] const XAPO_PROCESS_BUFFER_PARAMETERS* pInputProcessParameters,[None] UINT32 OutputProcessParameterCount,[InOut, Buffer, Optional] XAPO_PROCESS_BUFFER_PARAMETERS* pOutputProcessParameters,[None] BOOL IsEnabled) + + + + Returns the number of input frames required to generate the given number of output frames. + + This pointer + The number of output frames desired. + No documentation. + UINT32 IXAPO::CalcInputFrames([None] UINT32 OutputFrameCount) + + + + Returns the number of output frames that will be generated from a given number of input frames. + + This Pointer + The number of input frames. + No documentation. + UINT32 IXAPO::CalcOutputFrames([None] UINT32 InputFrameCount) + + + + Native Accessor to an existing AudioProcessor instance + + + Interface that defines an XAPO, allowing it to be used in an XAudio2 effect chain. + + IXAPO + + + + Queries if a specific input format is supported for a given output format. + + Output format. + Input format to check for being supported. + If not NULL, and the input format is not supported for the given output format, ppSupportedInputFormat returns a pointer to the closest input format that is supported. Use {{XAPOFree}} to free the returned structure. + No documentation. + HRESULT IXAPO::IsInputFormatSupported([None] const WAVEFORMATEX* pOutputFormat,[None] const WAVEFORMATEX* pRequestedInputFormat,[Out, Optional] WAVEFORMATEX** ppSupportedInputFormat) + + + + Queries if a specific output format is supported for a given input format. + + [in] Input format. + [in] Output format to check for being supported. + [out] If not NULL and the output format is not supported for the given input format, ppSupportedOutputFormat returns a pointer to the closest output format that is supported. Use {{XAPOFree}} to free the returned structure. + No documentation. + HRESULT IXAPO::IsOutputFormatSupported([None] const WAVEFORMATEX* pInputFormat,[None] const WAVEFORMATEX* pRequestedOutputFormat,[Out, Optional] WAVEFORMATEX** ppSupportedOutputFormat) + + + + Performs any effect-specific initialization. + + Effect-specific initialization parameters, may be NULL if DataByteSize is 0. + No documentation. + HRESULT IXAPO::Initialize([In, Buffer, Optional] const void* pData,[None] UINT32 DataByteSize) + + + + Resets variables dependent on frame history. + + void IXAPO::Reset() + + + + Called by XAudio2 to lock the input and output configurations of an XAPO allowing it to + do any final initialization before {{Process}} is called on the realtime thread. + + Array of input structures.pInputLockedParameters may be NULL if InputLockedParameterCount is 0, otherwise itmust have InputLockedParameterCount elements. + Array of output structures.pOutputLockedParameters may be NULL if OutputLockedParameterCount is 0, otherwise itmust have OutputLockedParameterCount elements. + No documentation. + HRESULT IXAPO::LockForProcess([None] UINT32 InputLockedParameterCount,[In, Buffer, Optional] const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pInputLockedParameters,[None] UINT32 OutputLockedParameterCount,[In, Buffer, Optional] const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pOutputLockedParameters) + + + + Deallocates variables that were allocated with the {{LockForProcess}} method. + + void IXAPO::UnlockForProcess() + + + + Runs the XAPO's digital signal processing (DSP) code on the given input and output buffers. + + [in] Input array of structures. + [in, out] Output array of structures. On input, the value of .ValidFrameCount indicates the number of frames that the XAPO should write to the output buffer. On output, the value of .ValidFrameCount indicates the actual number of frames written. + TRUE to process normally; FALSE to process thru. See Remarks for additional information. + void IXAPO::Process([None] UINT32 InputProcessParameterCount,[In, Buffer, Optional] const XAPO_PROCESS_BUFFER_PARAMETERS* pInputProcessParameters,[None] UINT32 OutputProcessParameterCount,[InOut, Buffer, Optional] XAPO_PROCESS_BUFFER_PARAMETERS* pOutputProcessParameters,[None] BOOL IsEnabled) + + + + Returns the number of input frames required to generate the given number of output frames. + + The number of output frames desired. + No documentation. + UINT32 IXAPO::CalcInputFrames([None] UINT32 OutputFrameCount) + + + + Returns the number of output frames that will be generated from a given number of input frames. + + The number of input frames. + No documentation. + UINT32 IXAPO::CalcOutputFrames([None] UINT32 InputFrameCount) + + + + Initializes a new instance of the class. + + The native pointer. + + + + Returns the registration properties of an XAPO. + + Receives a reference to a structure containing theregistration properties the XAPO was created with; use XAPOFree to free thestructure. + No documentation. + HRESULT IXAPO::GetRegistrationProperties([Out] XAPO_REGISTRATION_PROPERTIES** ppRegistrationProperties) + + + + Queries if a specific input format is supported for a given output format. + + Output format. + Input format to check for being supported. + If not NULL, and the input format is not supported for the given output format, ppSupportedInputFormat returns a reference to the closest input format that is supported. Use {{XAPOFree}} to free the returned structure. + No documentation. + HRESULT IXAPO::IsInputFormatSupported([None] const WAVEFORMATEX* pOutputFormat,[None] const WAVEFORMATEX* pRequestedInputFormat,[Out, Optional] WAVEFORMATEX** ppSupportedInputFormat) + + + + Queries if a specific output format is supported for a given input format. + + [in] Input format. + [in] Output format to check for being supported. + [out] If not NULL and the output format is not supported for the given input format, ppSupportedOutputFormat returns a reference to the closest output format that is supported. Use {{XAPOFree}} to free the returned structure. + No documentation. + HRESULT IXAPO::IsOutputFormatSupported([None] const WAVEFORMATEX* pInputFormat,[None] const WAVEFORMATEX* pRequestedOutputFormat,[Out, Optional] WAVEFORMATEX** ppSupportedOutputFormat) + + + + Performs any effect-specific initialization. + + Effect-specific initialization parameters, may be NULL if DataByteSize is 0. + Size of pData in bytes, may be 0 if pData is NULL. + No documentation. + HRESULT IXAPO::Initialize([In, Buffer, Optional] const void* pData,[None] int DataByteSize) + + + + Resets variables dependent on frame history. + + void IXAPO::Reset() + + + + Called by XAudio2 to lock the input and output configurations of an XAPO allowing it to + do any final initialization before {{Process}} is called on the realtime thread. + + Number of elements in ppInputLockedParameters. Must be within the .MinInputBufferCount and .MaxInputBufferCount values passed to {{CXAPOBase::CXAPOBase}}. + Array of input structures.pInputLockedParameters may be NULL if InputLockedParameterCount is 0, otherwise itmust have InputLockedParameterCount elements. + Number of elements in ppOutputLockedParameters. Must be within the .MinOutputBufferCount and .MaxOutputBufferCount values passed to {{CXAPOBase::CXAPOBase}}. If the XAPO_FLAG_BUFFERCOUNT_MUST_MATCH flag was specified in .Flags then OutputLockedParameterCount must equalInputLockedParameterCount. + Array of output structures.pOutputLockedParameters may be NULL if OutputLockedParameterCount is 0, otherwise itmust have OutputLockedParameterCount elements. + No documentation. + HRESULT IXAPO::LockForProcess([None] int InputLockedParameterCount,[In, Buffer] const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pInputLockedParameters,[None] int OutputLockedParameterCount,[In, Buffer] const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pOutputLockedParameters) + + + + Deallocates variables that were allocated with the {{LockForProcess}} method. + + void IXAPO::UnlockForProcess() + + + + Runs the XAPO's digital signal processing (DSP) code on the given input and output buffers. + + [in] Number of elements in pInputProcessParameters. Note XAudio2 currently supports only one input stream and one output stream. + [in] Input array of structures. + [in] Number of elements in pOutputProcessParameters. Note XAudio2 currently supports only one input stream and one output stream. + [in, out] Output array of structures. On input, the value of .ValidFrameCount indicates the number of frames that the XAPO should write to the output buffer. On output, the value of .ValidFrameCount indicates the actual number of frames written. + TRUE to process normally; FALSE to process thru. See Remarks for additional information. + void IXAPO::Process([None] int InputProcessParameterCount,[In, Buffer, Optional] const XAPO_PROCESS_BUFFER_PARAMETERS* pInputProcessParameters,[None] int OutputProcessParameterCount,[In, Buffer] XAPO_PROCESS_BUFFER_PARAMETERS* pOutputProcessParameters,[None] BOOL IsEnabled) + + + + Returns the number of input frames required to generate the given number of output frames. + + The number of output frames desired. + No documentation. + int IXAPO::CalcInputFrames([None] int OutputFrameCount) + + + + Returns the number of output frames that will be generated from a given number of input frames. + + The number of input frames. + No documentation. + int IXAPO::CalcOutputFrames([None] int InputFrameCount) + + + + Returns the registration properties of an XAPO. + + a structure containing theregistration properties the XAPO was created with; use XAPOFree to free thestructure. + HRESULT IXAPO::GetRegistrationProperties([Out] XAPO_REGISTRATION_PROPERTIES** ppRegistrationProperties) + + + + Implements this class to call an existing unmanaged AudioProcessor which supports parameter. + + the parameter type of this AudioProcessor + + + + Initializes a new instance of the class. + + The base PTR. + + + + Update the Native Poinder. Rebuild ParameterProviderNative. + + + + + Get or Set the parameters for this AudioProcessor + + + + + No documentation. + + XAPO_BUFFER_FLAGS + + + + No documentation. + + XAPO_BUFFER_SILENT + + + + No documentation. + + XAPO_BUFFER_VALID + + + + None. + + None + + + + No documentation. + + XAPO_PROPERTY_TYPE + + + + No documentation. + + XAPO_PROPERTY_CHANNELS_MUST_MATCH + + + + No documentation. + + XAPO_PROPERTY_FRAMERATE_MUST_MATCH + + + + No documentation. + + XAPO_PROPERTY_BITSPERSAMPLE_MUST_MATCH + + + + No documentation. + + XAPO_PROPERTY_BUFFERCOUNT_MUST_MATCH + + + + No documentation. + + XAPO_PROPERTY_INPLACE_REQUIRED + + + + No documentation. + + XAPO_PROPERTY_INPLACE_SUPPORTED + + + + No documentation. + + Default + + + + XAPOFx Functions. + + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + + Load DLLs and bind functions + + + + + No documentation. + + No documentation. + No documentation. + No documentation. + HRESULT CreateFX([None] GUID* clsid,[Out] IUnknown** pEffect) + + + + No documentation. + + FXEQ_PARAMETERS + + + + No documentation. + + float FrequencyCenter0 + + + + No documentation. + + float Gain0 + + + + No documentation. + + float Bandwidth0 + + + + No documentation. + + float FrequencyCenter1 + + + + No documentation. + + float Gain1 + + + + No documentation. + + float Bandwidth1 + + + + No documentation. + + float FrequencyCenter2 + + + + No documentation. + + float Gain2 + + + + No documentation. + + float Bandwidth2 + + + + No documentation. + + float FrequencyCenter3 + + + + No documentation. + + float Gain3 + + + + No documentation. + + float Bandwidth3 + + + + No documentation. + + FXMASTERINGLIMITER_PARAMETERS + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + + No documentation. + + int Release + + + + No documentation. + + int Loudness + + + + No documentation. + + FXREVERB_PARAMETERS + + + + No documentation. + + float Diffusion + + + + No documentation. + + float RoomSize + + + + Parameters for use with the FXEcho XAPO. + + FXECHO_PARAMETERS + + + + Ratio of wet (processed) signal to dry (original) signal. + + float WetDryMix + + + + Amount of output to feed back into input. + + float Feedback + + + + Delay to all channels in milliseconds. + + float Delay + + + + An optional interface that allows an XAPO to use effect-specific parameters. + + IXAPOParameters + + + + Initializes a new instance of the class. + + The native pointer. + + + + Sets effect-specific parameters. + + Effect-specific parameter block. + Size of pParameters, in bytes. + void IXAPOParameters::SetParameters([In, Buffer] const void* pParameters,[None] int ParameterByteSize) + + + + Gets the current values for any effect-specific parameters. + + [in, out] Receives an effect-specific parameter block. + [in] Size of pParameters, in bytes. + void IXAPOParameters::GetParameters([Out, Buffer] void* pParameters,[None] int ParameterByteSize) + + + + No documentation. + + XAPO_REGISTRATION_PROPERTIES + + + + No documentation. + + GUID clsid + + + + No documentation. + + wchar_t FriendlyName[256] + + + + No documentation. + + wchar_t CopyrightInfo[256] + + + + No documentation. + + int MajorVersion + + + + No documentation. + + int MinorVersion + + + + No documentation. + + XAPO_PROPERTY_TYPE Flags + + + + No documentation. + + int MinInputBufferCount + + + + No documentation. + + int MaxInputBufferCount + + + + No documentation. + + int MinOutputBufferCount + + + + No documentation. + + int MaxOutputBufferCount + + + + No documentation. + + XAPO_LOCKFORPROCESS_PARAMETERS + + + + No documentation. + + const WAVEFORMATEX* pFormat + + + + No documentation. + + int MaxFrameCount + + + + Gets or sets the waveformat. + + The format. + + + + No documentation. + + XAPO_PROCESS_BUFFER_PARAMETERS + + + + No documentation. + + void* pBuffer + + + + No documentation. + + XAPO_BUFFER_FLAGS BufferFlags + + + + No documentation. + + int ValidFrameCount + + + + Internal AudioProcessorCallback + + IXAPOParameters + + + + Sets effect-specific parameters. + + This pointer + Effect-specific parameter block. + size of the parameters + void IXAPOParameters::SetParameters([In, Buffer] const void* pParameters,[None] UINT32 ParameterByteSize) + + + + Gets the current values for any effect-specific parameters. + + This pointer + [in, out] Receives an effect-specific parameter block. + size of the parameters + void IXAPOParameters::GetParameters([Out, Buffer] void* pParameters,[None] UINT32 ParameterByteSize) + + + + An Echo XAPO AudioProcessor + + + + + Initializes a new instance of the class. + + + + + A Equalizer XAPO AudioProcessor + + + + + Initializes a new instance of the class. + + + + + A MateringLimiter XAPO AudioProcessor + + + + + Initializes a new instance of the class. + + + + + A Reverb XAPO AudioProcessor + + + + + Initializes a new instance of the class. + + + + diff --git a/Libs/SharpDX.XAudio2.dll b/Libs/SharpDX.XAudio2.dll new file mode 100644 index 0000000000000000000000000000000000000000..82e8bc38e1ffc94d23100b0e68c1ac80dabec6b6 GIT binary patch literal 29696 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 Q{zAUE>i=W^^DXdy0A704R{#J2 literal 0 HcmV?d00001 diff --git a/Libs/SharpDX.XAudio2.xml b/Libs/SharpDX.XAudio2.xml new file mode 100644 index 0000000..f9b18fc --- /dev/null +++ b/Libs/SharpDX.XAudio2.xml @@ -0,0 +1,2156 @@ + + + + SharpDX.XAudio2 + + + + + No documentation. + + XAUDIO2_EFFECT_DESCRIPTOR + + + + Initializes a new instance of the class with a Stereo Effect. + + The effect. + + + + Initializes a new instance of the class. + + The effect. + The output channel count. + + + + No documentation. + + IUnknown* pEffect + + + + No documentation. + + int OutputChannels + + + + Gets or sets the AudioProcessor. The AudioProcessor cannot be set more than one. + + The effect. + + + + No documentation. + + BOOL InitialState + + + + Represents an audio data buffer, used with . + + XAUDIO2_BUFFER + + + Constant None. + + + + Flags that provide additional information about the audio buffer. May be 0, or the following value. ValueDescriptionXAUDIO2_END_OF_STREAMIndicates that there cannot be any buffers in the queue after this buffer. The only effect of this flag is to suppress debug output warnings caused by starvation of the buffer queue.? + + XAUDIO2_BUFFER_FLAGS Flags + + + + Size of the audio data, in bytes. Must be no larger than XAUDIO2_MAX_BUFFER_BYTES (defined in xaudio2.h) for PCM data and no larger than XMA_READBUFFER_MAX_BYTES (defined in xma2defs.h) for XMA data. Note XMA buffers submitted to an XAudio2 voice using must contain complete XMA blocks. A complete XMA block must be equal in size to the XMA2WAVEFORMATEX.BytesPerBlock value, except for the last XMA block in a file, which may be shorter but will still be considered complete. + + int AudioBytes + + + + Pointer to the audio data. Xbox 360 The memory allocated for a buffer containing XMA data must have a block alignment of 2048. This is accomplished using XPhysicalAlloc with the ulAlignment argument set to 2048. + + const byte* pAudioData + + + + First sample in the buffer that should be played. For XMA buffers this value must be a multiple of 128 samples. + + int PlayBegin + + + + Length of the region to be played, in samples. A value of zero means to play the entire buffer, and, in this case, PlayBegin must be zero as well. For XMA data this value must be a multiple of 128 samples. For ADPCM data this value must be a multiple of wSamplesPerBlock in the {{ADPCMWAVEFORMAT}} structure that contains this XAUDIO2_BUFFER structure. + + int PlayLength + + + + First sample of the region to be looped. The value of LoopBegin must be less than PlayBegin + PlayLength. LoopBegin can be less than PlayBegin. LoopBegin must be 0 if LoopCount is 0. For XMA data this value must be a multiple of 128 samples. For xWMA data this value must be 0, see {{xWMA Overview}} for additional information. + + int LoopBegin + + + + Length of the loop region, in samples. The value of LoopBegin+LoopLength must be greater than PlayBegin and less than PlayBegin + PlayLength. LoopLength must be zero if LoopCount is 0. If LoopCount is not 0 then a loop length of zero indicates the entire sample should be looped. For XMA data this value must be a multiple of 128 samples. For ADPCM data this value must be a multiple of wSamplesPerBlock in the {{ADPCMWAVEFORMAT}} structure that contains this XAUDIO2_BUFFER structure. For xWMA data this value must be 0 or equal to the number of samples of the entire buffer, see {{xWMA Overview}} for additional information. + + int LoopLength + + + + Number of times to loop through the loop region. This value can be between 0 and XAUDIO2_MAX_LOOP_COUNT. If LoopCount is zero no looping is performed and LoopBegin and LoopLength must be 0. To loop forever, set LoopCount to XAUDIO2_LOOP_INFINITE. For xWMA data if this value is not 0 then Flags must be XAUDIO2_END_OF_STREAM, see {{xWMA Overview}} for additional information. + + int LoopCount + + + + Context value to be passed back in callbacks to the client. This may be NULL. + + void* pContext + + + + Gets or sets the datastream associated to this audio buffer + + The stream. + + + + The IXAudio2EngineCallback interface contains methods that notify the client when certain events happen in the engine. This interface should be implemented by the XAudio2 client. XAudio2 calls these methods via an interface pointer provided by the client, using either the {{XAudio2Create}} or method. Methods in this interface return void, rather than an HRESULT. + + IXAudio2EngineCallback + + The IXAudio2EngineCallback interface contains methods that notify the client when certain events happen in the engine. This interface should be implemented by the XAudio2 client. XAudio2 calls these methods via an interface reference provided by the client, using either the {{XAudio2Create}} or method. Methods in this interface return void, rather than an HRESULT. + + IXAudio2EngineCallback + + + + Called by XAudio2 just before an audio processing pass begins. + + void IXAudio2EngineCallback::OnProcessingPassStart() + + + + Called by XAudio2 just after an audio processing pass ends. + + void IXAudio2EngineCallback::OnProcessingPassEnd() + + + + Called if a critical system error occurs that requires XAudio2 to be closed down and restarted. + + Error code returned by XAudio2. + void IXAudio2EngineCallback::OnCriticalError([None] HRESULT Error) + + + + Internal EngineCallback Callback Impl + + + + + Called by XAudio2 just after an audio processing pass ends. + + void IXAudio2EngineCallback::OnProcessingPassEnd() + + + + Called if a critical system error occurs that requires XAudio2 to be closed down and restarted. + + This pointer + Error code returned by XAudio2. + void IXAudio2EngineCallback::OnCriticalError([None] HRESULT Error) + + + + EventArgs used by . + + + + + Initializes a new instance of the class. + + The error code. + + + + Gets or sets the error code. + + The error code. + + + + Windows-specific enumerator for available processors. + + XAUDIO2_WINDOWS_PROCESSOR_SPECIFIER + + + + No documentation. + + Processor1 + + + + No documentation. + + Processor2 + + + + No documentation. + + Processor3 + + + + No documentation. + + Processor4 + + + + No documentation. + + Processor5 + + + + No documentation. + + Processor6 + + + + No documentation. + + Processor7 + + + + No documentation. + + Processor8 + + + + No documentation. + + Processor9 + + + + No documentation. + + Processor10 + + + + No documentation. + + Processor11 + + + + No documentation. + + Processor12 + + + + No documentation. + + Processor13 + + + + No documentation. + + Processor14 + + + + No documentation. + + Processor15 + + + + No documentation. + + Processor16 + + + + No documentation. + + Processor17 + + + + No documentation. + + Processor18 + + + + No documentation. + + Processor19 + + + + No documentation. + + Processor20 + + + + No documentation. + + Processor21 + + + + No documentation. + + Processor22 + + + + No documentation. + + Processor23 + + + + No documentation. + + Processor24 + + + + No documentation. + + Processor25 + + + + No documentation. + + Processor26 + + + + No documentation. + + Processor27 + + + + No documentation. + + Processor28 + + + + No documentation. + + Processor29 + + + + No documentation. + + Processor30 + + + + No documentation. + + Processor31 + + + + No documentation. + + Processor32 + + + + No documentation. + + XAUDIO2_ANY_PROCESSOR + + + + No documentation. + + XAUDIO2_DEFAULT_PROCESSOR + + + + Used in the structure to describe the role assigned to the device by the user. + + XAUDIO2_DEVICE_ROLE + + + + No documentation. + + NotDefaultDevice + + + + No documentation. + + DefaultConsoleDevice + + + + No documentation. + + DefaultMultimediaDevice + + + + No documentation. + + DefaultCommunicationsDevice + + + + No documentation. + + DefaultGameDevice + + + + No documentation. + + GlobalDefaultDevice + + + + No documentation. + + InvalidDeviceRole + + + + Indicates whether a filter is low pass, band pass, high pass, or notch. + + XAUDIO2_FILTER_TYPE + + + + No documentation. + + LowPassFilter + + + + No documentation. + + BandPassFilter + + + + No documentation. + + HighPassFilter + + + + No documentation. + + NotchFilter + + + + No documentation. + + XAUDIO2_VOICE_SEND_FLAGS + + + + No documentation. + + XAUDIO2_VOICE_SEND_USEFILTER + + + + None. + + None + + + + No documentation. + + XAUDIO2_VOICE_FLAGS + + + + No documentation. + + XAUDIO2_VOICE_NOPITCH + + + + No documentation. + + XAUDIO2_VOICE_NOSRC + + + + No documentation. + + XAUDIO2_VOICE_USEFILTER + + + + No documentation. + + XAUDIO2_VOICE_MUSIC + + + + None. + + None + + + + No documentation. + + XAUDIO2_FLAGS + + + + No documentation. + + XAUDIO2_DEBUG_ENGINE + + + + None. + + None + + + + No documentation. + + XAUDIO2_PLAY_FLAGS + + + + No documentation. + + XAUDIO2_PLAY_TAILS + + + + None. + + None + + + + No documentation. + + XAUDIO2_LOG_TYPE + + + + No documentation. + + XAUDIO2_LOG_ERRORS + + + + No documentation. + + XAUDIO2_LOG_WARNINGS + + + + No documentation. + + XAUDIO2_LOG_INFO + + + + No documentation. + + XAUDIO2_LOG_DETAIL + + + + No documentation. + + XAUDIO2_LOG_API_CALLS + + + + No documentation. + + XAUDIO2_LOG_FUNC_CALLS + + + + No documentation. + + XAUDIO2_LOG_TIMING + + + + No documentation. + + XAUDIO2_LOG_LOCKS + + + + No documentation. + + XAUDIO2_LOG_MEMORY + + + + No documentation. + + XAUDIO2_LOG_STREAMING + + + + No documentation. + + XAUDIO2_BUFFER_FLAGS + + + + No documentation. + + XAUDIO2_END_OF_STREAM + + + + None. + + None + + + + XAudio2FxContants Functions. + + + + Constant None. + + + Constant None. + + + Constant None. + + + Constant None. + + + + No documentation. + + XAUDIO2FX_VOLUMEMETER_LEVELS + + + + No documentation. + + float* pPeakLevels + + + + No documentation. + + float* pRMSLevels + + + + No documentation. + + int ChannelCount + + + + No documentation. + + XAUDIO2FX_REVERB_PARAMETERS + + + + No documentation. + + float WetDryMix + + + + No documentation. + + int ReflectionsDelay + + + + No documentation. + + byte ReverbDelay + + + + No documentation. + + byte RearDelay + + + + No documentation. + + byte PositionLeft + + + + No documentation. + + byte PositionRight + + + + No documentation. + + byte PositionMatrixLeft + + + + No documentation. + + byte PositionMatrixRight + + + + No documentation. + + byte EarlyDiffusion + + + + No documentation. + + byte LateDiffusion + + + + No documentation. + + byte LowEQGain + + + + No documentation. + + byte LowEQCutoff + + + + No documentation. + + byte HighEQGain + + + + No documentation. + + byte HighEQCutoff + + + + No documentation. + + float RoomFilterFreq + + + + No documentation. + + float RoomFilterMain + + + + No documentation. + + float RoomFilterHF + + + + No documentation. + + float ReflectionsGain + + + + No documentation. + + float ReverbGain + + + + No documentation. + + float DecayTime + + + + No documentation. + + float Density + + + + No documentation. + + float RoomSize + + + + No documentation. + + XAUDIO2FX_REVERB_I3DL2_PARAMETERS + + + + No documentation. + + float WetDryMix + + + + No documentation. + + int Room + + + + No documentation. + + int RoomHF + + + + No documentation. + + float RoomRolloffFactor + + + + No documentation. + + float DecayTime + + + + No documentation. + + float DecayHFRatio + + + + No documentation. + + int Reflections + + + + No documentation. + + float ReflectionsDelay + + + + No documentation. + + int Reverb + + + + No documentation. + + float ReverbDelay + + + + No documentation. + + float Diffusion + + + + No documentation. + + float Density + + + + No documentation. + + float HFReference + + + + IXAudio2 is the interface for the XAudio2 object, which manages all audio engine states, the audio processing thread, the voice graph, and so forth. This is the only XAudio2 interface that is derived from the COM IUnknown interface. It controls the lifetime of the XAudio2 object using two methods derived from IUnknown: {{IXAudio2::AddRef}} and {{IXAudio2::Release}}. No other XAudio2 objects are reference-counted; their lifetimes are explicitly controlled using create and destroy calls, and are bounded by the lifetime of the XAudio2 object that owns them. + + IXAudio2 + + + + Initializes a new instance of the class. + + The native pointer. + + + Constant None. + + + Constant None. + + + Constant None. + + + + Returns the number of available audio output devices. + + [out] Number of available audio output devices that is returned. On Xbox 360 this value will always be 1. + No documentation. + HRESULT IXAudio2::GetDeviceCount([Out] int* pCount) + + + + Returns information about an audio output device. + + [in] Index of the device to be queried. This value must be less than the count returned by . + [out] On success, reference to an structure that is returned. + No documentation. + HRESULT IXAudio2::GetDeviceDetails([None] int Index,[Out] XAUDIO2_DEVICE_DETAILS* pDeviceDetails) + + + + Sets XAudio2 parameters and prepares XAudio2 for use. + + [in] Flags that specify the behavior of the XAudio2 object. This value must be 0. + [in] An enumeration value that specifies which CPU to use. The values have different meanings on different platforms: Windows See the enumerator for details. Note Specifying a processor should generally be avoided because it can interfere with the scheduler's ability to schedule threads effectively across processors. Instead, pass the XAUDIO2_DEFAULT_PROCESSOR value. Xbox 360 See the {{XAUDIO2_XBOX_HWTHREAD_SPECIFIER}} enumerator for details. Specifying the value XAUDIO2_DEFAULT_PROCESSOR causes XAudio2 to use its default processor on each platform. Note that Xaudio2 only supports a single thread at a time and only one processor may be specified. + No documentation. + HRESULT IXAudio2::Initialize([None] int Flags,[None] XAUDIO2_PROCESSOR XAudio2Processor) + + + + Adds an reference to the {{XAudio2}} engine callback list. + + [in] reference to add to the {{XAudio2}} engine callback list. + No documentation. + HRESULT IXAudio2::RegisterForCallbacks([In] IXAudio2EngineCallback* pCallback) + + + + Removes an reference from the {{XAudio2}} engine callback list. + + [in] reference to remove from the {{XAudio2}} engine callback list. If the given reference is present more than once in the list, only the first instance in the list will be removed. + void IXAudio2::UnregisterForCallbacks([In] IXAudio2EngineCallback* pCallback) + + + + Creates and configures a source voice. + + [out] If successful, returns a reference to the new object. + [in] Pointer to a structure. This structure contains the expected format for all audio buffers submitted to the source voice. XAudio2 supports voice types of PCM, xWMA, ADPCM (Windows only), and XMA (Xbox 360 only). XAudio2 supports the following PCM formats. 8-bit (unsigned) integer PCM 16-bit integer PCM (Optimal format for XAudio2) 20-bit integer PCM (either in 24 or 32 bit containers) 24-bit integer PCM (either in 24 or 32 bit containers) 32-bit integer PCM 32-bit float PCM (Preferred format after 16-bit integer) The number of channels in a source voice must be less than or equal to XAUDIO2_MAX_AUDIO_CHANNELS. The sample rate of a source voice must be between XAUDIO2_MIN_SAMPLE_RATE and XAUDIO2_MAX_SAMPLE_RATE. Note Data formats such as XMA, {{ADPCM}}, and {{xWMA}} that require more information than provided by have a structure as the first member in their format structure. When creating a source voice with one of those formats cast the format's structure as a structure and use it as the value for pSourceFormat. + [in] Flags that specify the behavior of the source voice. A flag can be 0 or a combination of one or more of the following: ValueDescriptionXAUDIO2_VOICE_NOPITCHNo pitch control is available on the voice.?XAUDIO2_VOICE_NOSRCNo sample rate conversion is available on the voice, the voice's outputs must have the same sample rate.Note The XAUDIO2_VOICE_NOSRC flag causes the voice to behave as though the XAUDIO2_VOICE_NOPITCH flag also is specified. ?XAUDIO2_VOICE_USEFILTERThe filter effect should be available on this voice.?XAUDIO2_VOICE_MUSICThe voice is used to play background music. The system automatically can replace the voice with music selected by the user.? + [in] Highest allowable frequency ratio that can be set on this voice. The value for this argument must be between XAUDIO2_MIN_FREQ_RATIO and XAUDIO2_MAX_FREQ_RATIO. Subsequent calls to are clamped between XAUDIO2_MIN_FREQ_RATIO and MaxFrequencyRatio. The maximum value for this argument is defined as XAUDIO2_MAX_FREQ_RATIO, which allows pitch to be raised by up to 10 octaves. If MaxFrequencyRatio is less than 1.0, the voice will use that ratio immediately after being created (rather than the default of 1.0). Xbox 360 For XMA voices there is an additional restriction on the MaxFrequencyRatio argument and the voice's sample rate. The product of these two numbers cannot exceed XAUDIO2_MAX_RATIO_TIMES_RATE_XMA_MONO for one-channel voices or XAUDIO2_MAX_RATIO_TIMES_RATE_XMA_MULTICHANNEL for voices with any other number of channels. If the value specified for MaxFrequencyRatio is too high for the specified format, the call to CreateSourceVoice fails and produces a debug message. Note XAudio2's memory usage can be reduced by using the lowest possible MaxFrequencyRatio value. + [in, optional] Pointer to a client-provided callback interface, . + [in, optional] Pointer to a list of structures that describe the set of destination voices for the source voice. If pSendList is NULL, the send list defaults to a single output to the first mastering voice created. + [in, optional] Pointer to a list of structures that describe an effect chain to use in the source voice. + No documentation. + HRESULT IXAudio2::CreateSourceVoice([Out] IXAudio2SourceVoice** ppSourceVoice,[In] const WAVEFORMATEX* pSourceFormat,[None] XAUDIO2_VOICE_FLAGS Flags,[None] float MaxFrequencyRatio,[In, Optional] IXAudio2VoiceCallback* pCallback,[In, Optional] const XAUDIO2_VOICE_SENDS* pSendList,[In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + Creates and configures a submix voice. + + [out] On success, returns a reference to the new object. + [in] Number of channels in the input audio data of the submix voice. InputChannels must be less than or equal to XAUDIO2_MAX_AUDIO_CHANNELS. + [in] Sample rate of the input audio data of submix voice. This rate must be a multiple of XAUDIO2_QUANTUM_DENOMINATOR. InputSampleRate must be between XAUDIO2_MIN_SAMPLE_RATE and XAUDIO2_MAX_SAMPLE_RATE. + [in] Flags that specify the behavior of the submix voice. Can be 0 or the following: ValueDescriptionXAUDIO2_VOICE_USEFILTERThe filter effect should be available on this voice.? + [in] An arbitrary number that specifies when this voice is processed with respect to other submix voices, if the XAudio2 engine is running other submix voices. The voice is processed after all other voices that include a smaller ProcessingStage value, and before all other voices that include a larger ProcessingStage value. Voices that include the same ProcessingStage value are processed in any order. A submix voice cannot send to another submix voice with a lower or equal ProcessingStage value; this prevents audio being lost due to a submix cycle. + [in, optional] Pointer to a list of structures that describe the set of destination voices for the submix voice. If pSendList is NULL, the send list will default to a single output to the first mastering voice created. + [in, optional] Pointer to a list of structures that describe an effect chain to use in the submix voice. + No documentation. + HRESULT IXAudio2::CreateSubmixVoice([Out] IXAudio2SubmixVoice** ppSubmixVoice,[None] int InputChannels,[None] int InputSampleRate,[None] XAUDIO2_VOICE_SEND_FLAGS Flags,[None] int ProcessingStage,[In, Optional] const XAUDIO2_VOICE_SENDS* pSendList,[In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + Creates and configures a mastering voice. + + [out] If successful, returns a reference to the new object. + [in] Number of channels the mastering voice expects in its input audio. InputChannels must be less than or equal to XAUDIO2_MAX_AUDIO_CHANNELS. InputChannels can be set to XAUDIO2_DEFAULT_CHANNELS, with the default being determined by the current platform. Windows Attempts to detect the system speaker configuration setup. Xbox 360 Defaults to 5.1 surround. + [in] Sample rate of the input audio data of the mastering voice. This rate must be a multiple of XAUDIO2_QUANTUM_DENOMINATOR. InputSampleRate must be between XAUDIO2_MIN_SAMPLE_RATE and XAUDIO2_MAX_SAMPLE_RATE. InputSampleRate can be set to XAUDIO2_DEFAULT_SAMPLERATE, with the default being determined by the current platform. Windows Windows XP defaults to 44100. Windows Vista and Windows 7 default to the setting specified in the Sound Control Panel. The default for this setting is 44100 (or 48000 if required by the driver). Xbox 360 Defaults to 48000. + [in] Flags that specify the behavior of the mastering voice. Must be 0. + [in] Index of the output device that will be sent input by the mastering voice. Specifying the default value of 0 causes XAudio2 to select the global default audio device. + [in, optional] Pointer to an structure that describe an effect chain to use in the mastering voice, or NULL to use no effects. + No documentation. + HRESULT IXAudio2::CreateMasteringVoice([Out] IXAudio2MasteringVoice** ppMasteringVoice,[None] int InputChannels,[None] int InputSampleRate,[None] int Flags,[None] int DeviceIndex,[In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + Creates and starts the audio processing thread. + + No documentation. + HRESULT IXAudio2::StartEngine() + + + + Stops and destroys the audio processing thread. + + void IXAudio2::StopEngine() + + + + Atomically applies a set of operations that are tagged with a given identifier. + + [in] Identifier of the set of operations to be applied. To commit all pending operations, pass XAUDIO2_COMMIT_ALL. + No documentation. + HRESULT IXAudio2::CommitChanges([None] int OperationSet) + + + + Returns current resource usage details, such as available memory or CPU usage. + + [out] On success, reference to an structure that is returned. + void IXAudio2::GetPerformanceData([Out] XAUDIO2_PERFORMANCE_DATA* pPerfData) + + + + Changes global debug logging options for XAudio2. + + Pointer to a structure that contains the new debug configuration. + No documentation. + void IXAudio2::SetDebugConfiguration([In, Optional] const XAUDIO2_DEBUG_CONFIGURATION* pDebugConfiguration,[In, Optional] void* pReserved) + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + Specify a Debug or Normal XAudio2 instance. + The processor specifier. + + + + Releases unmanaged resources and performs other cleanup operations before the + is reclaimed by garbage collection. + + + + + Returns information about an audio output device. + + [in] Index of the device to be queried. This value must be less than the count returned by . + On success, pointer to an structure that is returned. + HRESULT IXAudio2::GetDeviceDetails([None] UINT32 Index,[Out] XAUDIO2_DEVICE_DETAILS* pDeviceDetails) + + + + Calculate a decibel from a volume. + + The volume. + a dB value + + + + Calculate radians from a cutoffs frequency. + + The cutoff frequency. + The sample rate. + radian + + + + Calculate a cutoff frequency from a radian. + + The radians. + The sample rate. + cutoff frequency + + + + Calculate a volume from a decibel + + a dB value + an amplitude value + + + + Calculate semitones from a Frequency ratio + + The frequency ratio. + semitones + + + + Calculate frequency from semitones. + + The semitones. + the frequency + + + + Atomically applies a set of operations for all pending operations. + + HRESULT IXAudio2::CommitChanges([None] UINT32 OperationSet) + + + + Returns the number of available audio output devices. + + HRESULT IXAudio2::GetDeviceCount([Out] int* pCount) + + + + Returns current resource usage details, such as available memory or CPU usage. + + void IXAudio2::GetPerformanceData([Out] XAUDIO2_PERFORMANCE_DATA* pPerfData) + + + + Called by XAudio2 just before an audio processing pass begins. + + + + + Called by XAudio2 just after an audio processing pass ends. + + + + + Called if a critical system error occurs that requires XAudio2 to be closed down and restarted. + + + + + IXAudio2Voice represents the base interface from which , and are derived. The methods listed below are common to all voice subclasses. + + IXAudio2Voice + + + + Initializes a new instance of the class. + + The native pointer. + + + + Returns information about the creation flags, input channels, and sample rate of a voice. + + [in, out] structure containing information about the voice. + void IXAudio2Voice::GetVoiceDetails([Out] XAUDIO2_VOICE_DETAILS* pVoiceDetails) + + + + Designates a new set of submix or mastering voices to receive the output of the voice. + + [in] Array of structure references to destination voices. If pSendList is NULL, the voice will send its output to the current mastering voice. To set the voice to not send its output anywhere set the OutputCount member of to 0. All of the voices in a send list must have the same input sample rate, see {{XAudio2 Sample Rate Conversions}} for additional information. + No documentation. + HRESULT IXAudio2Voice::SetOutputVoices([In, Optional] const XAUDIO2_VOICE_SENDS* pSendList) + + + + Replaces the effect chain of the voice. + + [in, optional] Pointer to an structure that describes the new effect chain to use. If NULL is passed, the current effect chain is removed. Note If pEffectChain is non-NULL, the structure that it points to must specify at least one effect. + No documentation. + HRESULT IXAudio2Voice::SetEffectChain([In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + Enables the effect at a given position in the effect chain of the voice. + + [in] Zero-based index of an effect in the effect chain of the voice. + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2Voice::EnableEffect([None] int EffectIndex,[None] int OperationSet) + + + + Disables the effect at a given position in the effect chain of the voice. + + [in] Zero-based index of an effect in the effect chain of the voice. + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2Voice::DisableEffect([None] int EffectIndex,[None] int OperationSet) + + + + Returns the running state of the effect at a specified position in the effect chain of the voice. + + [in] Zero-based index of an effect in the effect chain of the voice. + [out] Returns TRUE If the effect is enabled. If the effect is disabled, returns FALSE. + void IXAudio2Voice::GetEffectState([None] int EffectIndex,[Out] BOOL* pEnabled) + + + + Sets parameters for a given effect in the voice's effect chain. + + [in] Zero-based index of an effect within the voice's effect chain. + [in] Returns the current values of the effect-specific parameters. + [in] Size of the pParameters array in bytes. + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2Voice::SetEffectParameters([None] int EffectIndex,[In, Buffer] const void* pParameters,[None] int ParametersByteSize,[None] int OperationSet) + + + + Returns the current effect-specific parameters of a given effect in the voice's effect chain. + + [in] Zero-based index of an effect within the voice's effect chain. + [out] Returns the current values of the effect-specific parameters. + [out] Size, in bytes, of the pParameters array. + No documentation. + HRESULT IXAudio2Voice::GetEffectParameters([None] int EffectIndex,[Out, Buffer] void* pParameters,[None] int ParametersByteSize) + + + + Sets the voice's filter parameters. + + [in] Pointer to an structure containing the filter information. + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2Voice::SetFilterParameters([In] const XAUDIO2_FILTER_PARAMETERS* pParameters,[None] int OperationSet) + + + + Gets the voice's filter parameters. + + [out] Pointer to an structure containing the filter information. + void IXAudio2Voice::GetFilterParameters([Out] XAUDIO2_FILTER_PARAMETERS* pParameters) + + + + Sets the filter parameters on one of this voice's sends. + + [in] reference to the destination voice of the send whose filter parameters will be set. + [in] Pointer to an structure containing the filter information. + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2Voice::SetOutputFilterParameters([In, Optional] IXAudio2Voice* pDestinationVoice,[In] const XAUDIO2_FILTER_PARAMETERS* pParameters,[None] int OperationSet) + + + + Returns the filter parameters from one of this voice's sends. + + [in] reference to the destination voice of the send whose filter parameters will be read. + [out] Pointer to an structure containing the filter information. + void IXAudio2Voice::GetOutputFilterParameters([In, Optional] IXAudio2Voice* pDestinationVoice,[Out] XAUDIO2_FILTER_PARAMETERS* pParameters) + + + + Sets the overall volume level for the voice. + + [in] Overall volume level to use. See Remarks for more information on volume levels. + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2Voice::SetVolume([None] float Volume,[None] int OperationSet) + + + + Gets the current overall volume level of the voice. + + [out] Returns the current overall volume level of the voice. See Remarks for more information on volume levels. + void IXAudio2Voice::GetVolume([Out] float* pVolume) + + + + Sets the volume levels for the voice, per channel. + + [in] Number of channels in the voice. + [in] Array containing the new volumes of each channel in the voice. The array must have Channels elements. See Remarks for more information on volume levels. + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2Voice::SetChannelVolumes([None] int Channels,[In, Buffer] const float* pVolumes,[None] int OperationSet) + + + + Returns the volume levels for the voice, per channel. + + [in] Confirms the channel count of the voice. + [out] Returns the current volume level of each channel in the voice. The array must have at least Channels elements. See Remarks for more information on volume levels. + void IXAudio2Voice::GetChannelVolumes([None] int Channels,[Out, Buffer] float* pVolumes) + + + + Sets the volume level of each channel of the final output for the voice. These channels are mapped to the input channels of a specified destination voice. + + [in] Pointer to a destination for which to set volume levels. Note If the voice sends to a single target voice then specifying NULL will cause SetOutputMatrix to operate on that target voice. + [in] Confirms the output channel count of the voice. This is the number of channels that are produced by the last effect in the chain. + [in] Confirms the input channel count of the destination voice. + [in] Array of [SourceChannels ? DestinationChannels] volume levels sent to the destination voice. The level sent from source channel S to destination channel D is specified in the form pLevelMatrix[SourceChannels ? D + S]. For example, when rendering two-channel stereo input into 5.1 output that is weighted toward the front channels?but is absent from the center and low-frequency channels?the matrix might have the values shown in the following table. OutputLeft InputRight Input Left1.00.0 Right0.01.0 Front Center0.00.0 LFE0.00.0 Rear Left0.80.0 Rear Right0.00.8 Note that the left and right input are fully mapped to the output left and right channels; 80 percent of the left and right input is mapped to the rear left and right channels. See Remarks for more information on volume levels. + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2Voice::SetOutputMatrix([In, Optional] IXAudio2Voice* pDestinationVoice,[None] int SourceChannels,[None] int DestinationChannels,[In, Buffer] const float* pLevelMatrix,[None] int OperationSet) + + + + Gets the volume level of each channel of the final output for the voice. These channels are mapped to the input channels of a specified destination voice. + + [in] Pointer specifying the destination to retrieve the output matrix for. Note If the voice sends to a single target voice then specifying NULL will cause GetOutputMatrix to operate on that target voice. + [in] Confirms the output channel count of the voice. This is the number of channels that are produced by the last effect in the chain. + [in] Confirms the input channel count of the destination voice. + [out] Array of [SourceChannels * DestinationChannels] volume levels sent to the destination voice. The level sent from source channel S to destination channel D is returned in the form pLevelMatrix[DestinationChannels ? S + D]. See Remarks for more information on volume levels. + void IXAudio2Voice::GetOutputMatrix([In, Optional] IXAudio2Voice* pDestinationVoice,[None] int SourceChannels,[None] int DestinationChannels,[Out, Buffer] float* pLevelMatrix) + + + + Destroys the voice. If necessary, stops the voice and removes it from the XAudio2 graph. + + void IXAudio2Voice::DestroyVoice() + + + + Enables the effect at a given position in the effect chain of the voice. + + [in] Zero-based index of an effect in the effect chain of the voice. + No documentation. + HRESULT IXAudio2Voice::EnableEffect([None] UINT32 EffectIndex,[None] UINT32 OperationSet) + + + + Disables the effect at a given position in the effect chain of the voice. + + [in] Zero-based index of an effect in the effect chain of the voice. + No documentation. + HRESULT IXAudio2Voice::DisableEffect([None] UINT32 EffectIndex,[None] UINT32 OperationSet) + + + + Returns the running state of the effect at a specified position in the effect chain of the voice. + + [in] Zero-based index of an effect in the effect chain of the voice. + Returns TRUE If the effect is enabled. If the effect is disabled, returns FALSE. + void IXAudio2Voice::GetEffectState([None] UINT32 EffectIndex,[Out] BOOL* pEnabled) + + + + Sets parameters for a given effect in the voice's effect chain. + + [in] Zero-based index of an effect within the voice's effect chain. + Returns the current values of the effect-specific parameters. + HRESULT IXAudio2Voice::SetEffectParameters([None] UINT32 EffectIndex,[In, Buffer] const void* pParameters,[None] UINT32 ParametersByteSize,[None] UINT32 OperationSet) + + + + Returns the current effect-specific parameters of a given effect in the voice's effect chain. + + [in] Zero-based index of an effect within the voice's effect chain. + [out] Returns the current values of the effect-specific parameters. + No documentation. + HRESULT IXAudio2Voice::GetEffectParameters([None] UINT32 EffectIndex,[Out, Buffer] void* pParameters,[None] UINT32 ParametersByteSize) + + + + Sets parameters for a given effect in the voice's effect chain. + + [in] Zero-based index of an effect within the voice's effect chain. + [in] Returns the current values of the effect-specific parameters. + No documentation. + HRESULT IXAudio2Voice::SetEffectParameters([None] UINT32 EffectIndex,[In, Buffer] const void* pParameters,[None] UINT32 ParametersByteSize,[None] UINT32 OperationSet) + + + + Sets parameters for a given effect in the voice's effect chain. + + [in] Zero-based index of an effect within the voice's effect chain. + [in] Returns the current values of the effect-specific parameters. + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2Voice::SetEffectParameters([None] UINT32 EffectIndex,[In, Buffer] const void* pParameters,[None] UINT32 ParametersByteSize,[None] UINT32 OperationSet) + + + + Sets parameters for a given effect in the voice's effect chain. + + [in] Zero-based index of an effect within the voice's effect chain. + [in] Returns the current values of the effect-specific parameters. + No documentation. + HRESULT IXAudio2Voice::SetEffectParameters([None] UINT32 EffectIndex,[In, Buffer] const void* pParameters,[None] UINT32 ParametersByteSize,[None] UINT32 OperationSet) + + + + Sets parameters for a given effect in the voice's effect chain. + + [in] Zero-based index of an effect within the voice's effect chain. + [in] Returns the current values of the effect-specific parameters. + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2Voice::SetEffectParameters([None] UINT32 EffectIndex,[In, Buffer] const void* pParameters,[None] UINT32 ParametersByteSize,[None] UINT32 OperationSet) + + + + Replaces the effect chain of the voice. + + [in, optional] an array of structure that describes the new effect chain to use. If NULL is passed, the current effect chain is removed. If array is non null, its length must be at least of 1. + No documentation. + HRESULT IXAudio2Voice::SetEffectChain([In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + Designates a new set of submix or mastering voices to receive the output of the voice. + + [in] Array of structure pointers to destination voices. If outputVoices is NULL, the voice will send its output to the current mastering voice. To set the voice to not send its output anywhere set an array of lenvth 0. All of the voices in a send list must have the same input sample rate, see {{XAudio2 Sample Rate Conversions}} for additional information. + No documentation. + HRESULT IXAudio2Voice::SetOutputVoices([In, Optional] const XAUDIO2_VOICE_SENDS* pSendList) + + + + Sets the volume level of each channel of the final output for the voice. These channels are mapped to the input channels of a specified destination voice. + + [in] Confirms the output channel count of the voice. This is the number of channels that are produced by the last effect in the chain. + [in] Confirms the input channel count of the destination voice. + [in] Array of [SourceChannels ? DestinationChannels] volume levels sent to the destination voice. The level sent from source channel S to destination channel D is specified in the form pLevelMatrix[SourceChannels ? D + S]. For example, when rendering two-channel stereo input into 5.1 output that is weighted toward the front channels?but is absent from the center and low-frequency channels?the matrix might have the values shown in the following table. OutputLeft InputRight Input Left1.00.0 Right0.01.0 Front Center0.00.0 LFE0.00.0 Rear Left0.80.0 Rear Right0.00.8 Note that the left and right input are fully mapped to the output left and right channels; 80 percent of the left and right input is mapped to the rear left and right channels. See Remarks for more information on volume levels. + No documentation. + HRESULT IXAudio2Voice::SetOutputMatrix([In, Optional] IXAudio2Voice* pDestinationVoice,[None] UINT32 SourceChannels,[None] UINT32 DestinationChannels,[In, Buffer] const float* pLevelMatrix,[None] UINT32 OperationSet) + + + + Sets the volume level of each channel of the final output for the voice. These channels are mapped to the input channels of a specified destination voice. + + [in] Pointer to a destination for which to set volume levels. Note If the voice sends to a single target voice then specifying NULL will cause SetOutputMatrix to operate on that target voice. + [in] Confirms the output channel count of the voice. This is the number of channels that are produced by the last effect in the chain. + [in] Confirms the input channel count of the destination voice. + [in] Array of [SourceChannels ? DestinationChannels] volume levels sent to the destination voice. The level sent from source channel S to destination channel D is specified in the form pLevelMatrix[SourceChannels ? D + S]. For example, when rendering two-channel stereo input into 5.1 output that is weighted toward the front channels?but is absent from the center and low-frequency channels?the matrix might have the values shown in the following table. OutputLeft InputRight Input Left1.00.0 Right0.01.0 Front Center0.00.0 LFE0.00.0 Rear Left0.80.0 Rear Right0.00.8 Note that the left and right input are fully mapped to the output left and right channels; 80 percent of the left and right input is mapped to the rear left and right channels. See Remarks for more information on volume levels. + No documentation. + HRESULT IXAudio2Voice::SetOutputMatrix([In, Optional] IXAudio2Voice* pDestinationVoice,[None] UINT32 SourceChannels,[None] UINT32 DestinationChannels,[In, Buffer] const float* pLevelMatrix,[None] UINT32 OperationSet) + + + + Sets the volume level of each channel of the final output for the voice. These channels are mapped to the input channels of a specified destination voice. + + [in] Confirms the output channel count of the voice. This is the number of channels that are produced by the last effect in the chain. + [in] Confirms the input channel count of the destination voice. + [in] Array of [SourceChannels ? DestinationChannels] volume levels sent to the destination voice. The level sent from source channel S to destination channel D is specified in the form pLevelMatrix[SourceChannels ? D + S]. For example, when rendering two-channel stereo input into 5.1 output that is weighted toward the front channels?but is absent from the center and low-frequency channels?the matrix might have the values shown in the following table. OutputLeft InputRight Input Left1.00.0 Right0.01.0 Front Center0.00.0 LFE0.00.0 Rear Left0.80.0 Rear Right0.00.8 Note that the left and right input are fully mapped to the output left and right channels; 80 percent of the left and right input is mapped to the rear left and right channels. See Remarks for more information on volume levels. + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2Voice::SetOutputMatrix([In, Optional] IXAudio2Voice* pDestinationVoice,[None] UINT32 SourceChannels,[None] UINT32 DestinationChannels,[In, Buffer] const float* pLevelMatrix,[None] UINT32 OperationSet) + + + + Returns information about the creation flags, input channels, and sample rate of a voice. + + void IXAudio2Voice::GetVoiceDetails([Out] XAUDIO2_VOICE_DETAILS* pVoiceDetails) + + + + Designates a new set of submix or mastering voices to receive the output of the voice. + + HRESULT IXAudio2Voice::SetOutputVoices([In, Optional] const XAUDIO2_VOICE_SENDS* pSendList) + + + + Gets the voice's filter parameters. + + void IXAudio2Voice::GetFilterParameters([Out] XAUDIO2_FILTER_PARAMETERS* pParameters) + + + + Gets the current overall volume level of the voice. + + void IXAudio2Voice::GetVolume([Out] float* pVolume) + + + + A source voice is used to submit audio data into the XAudio2 processing pipeline. Voice data must be sent to a mastering voice to be heard, either directly or through intermediate submix voices. + + IXAudio2SourceVoice + + + + Initializes a new instance of the class. + + The native pointer. + + + + Starts consumption and processing of audio by the voice. Delivers the result to any connected submix or mastering voices, or to the output device. + + [in] Flags that control how the voice is started. Must be 0. + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2SourceVoice::Start([None] int Flags,[None] int OperationSet) + + + + Stops consumption of audio by the current voice. + + [in] Flags that control how the voice is stopped. Can be 0 or the following: ValueDescriptionXAUDIO2_PLAY_TAILSContinue emitting effect output after the voice is stopped.? + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2SourceVoice::Stop([None] XAUDIO2_PLAY_FLAGS Flags,[None] int OperationSet) + + + + Adds a new audio buffer to the voice queue. + + [in] Pointer to an structure to queue. + [in] Pointer to an additional structure used when submitting WMA data. + No documentation. + HRESULT IXAudio2SourceVoice::SubmitSourceBuffer([In] const XAUDIO2_BUFFER* pBuffer,[In, Optional] const XAUDIO2_BUFFER_WMA* pBufferWMA) + + + + Removes all pending audio buffers from the voice queue. + + No documentation. + HRESULT IXAudio2SourceVoice::FlushSourceBuffers() + + + + Notifies an XAudio2 voice that no more buffers are coming after the last one that is currently in its queue. + + No documentation. + HRESULT IXAudio2SourceVoice::Discontinuity() + + + + Stops looping the voice when it reaches the end of the current loop region. + + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2SourceVoice::ExitLoop([None] int OperationSet) + + + + Returns the voice's current cursor position data. + + Pointer to an structure containing the state of the voice. + void IXAudio2SourceVoice::GetState([Out] XAUDIO2_VOICE_STATE* pVoiceState) + + + + Sets the frequency adjustment ratio of the voice. + + [in] Frequency adjustment ratio. This value must be between XAUDIO2_MIN_FREQ_RATIO and the MaxFrequencyRatio parameter specified when the voice was created (see ). XAUDIO2_MIN_FREQ_RATIO currently is 0.0005, which allows pitch to be lowered by up to 11 octaves. + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2SourceVoice::SetFrequencyRatio([None] float Ratio,[None] int OperationSet) + + + + Returns the frequency adjustment ratio of the voice. + + [out] Returns the current frequency adjustment ratio if successful. + void IXAudio2SourceVoice::GetFrequencyRatio([Out] float* pRatio) + + + + Reconfigures the voice to consume source data at a different sample rate than the rate specified when the voice was created. + + [in] The new sample rate the voice should process submitted data at. Valid sample rates are 1kHz to 200kHz. + No documentation. + HRESULT IXAudio2SourceVoice::SetSourceSampleRate([None] int NewSourceSampleRate) + + + + Creates and configures a source voice. + + an instance of + [in] Pointer to a structure. This structure contains the expected format for all audio buffers submitted to the source voice. XAudio2 supports voice types of PCM, xWMA, ADPCM (Windows only), and XMA (Xbox 360 only). XAudio2 supports the following PCM formats. 8-bit (unsigned) integer PCM 16-bit integer PCM (Optimal format for XAudio2) 20-bit integer PCM (either in 24 or 32 bit containers) 24-bit integer PCM (either in 24 or 32 bit containers) 32-bit integer PCM 32-bit float PCM (Preferred format after 16-bit integer) The number of channels in a source voice must be less than or equal to XAUDIO2_MAX_AUDIO_CHANNELS. The sample rate of a source voice must be between XAUDIO2_MIN_SAMPLE_RATE and XAUDIO2_MAX_SAMPLE_RATE. Note Data formats such as XMA, {{ADPCM}}, and {{xWMA}} that require more information than provided by have a structure as the first member in their format structure. When creating a source voice with one of those formats cast the format's structure as a structure and use it as the value for pSourceFormat. + No documentation. + HRESULT IXAudio2::CreateSourceVoice([Out] IXAudio2SourceVoice** ppSourceVoice,[In] const WAVEFORMATEX* pSourceFormat,[None] UINT32 Flags,[None] float MaxFrequencyRatio,[In, Optional] IXAudio2VoiceCallback* pCallback,[In, Optional] const XAUDIO2_VOICE_SENDS* pSendList,[In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + Creates and configures a source voice. + + an instance of + [in] Pointer to a structure. This structure contains the expected format for all audio buffers submitted to the source voice. XAudio2 supports voice types of PCM, xWMA, ADPCM (Windows only), and XMA (Xbox 360 only). XAudio2 supports the following PCM formats. 8-bit (unsigned) integer PCM 16-bit integer PCM (Optimal format for XAudio2) 20-bit integer PCM (either in 24 or 32 bit containers) 24-bit integer PCM (either in 24 or 32 bit containers) 32-bit integer PCM 32-bit float PCM (Preferred format after 16-bit integer) The number of channels in a source voice must be less than or equal to XAUDIO2_MAX_AUDIO_CHANNELS. The sample rate of a source voice must be between XAUDIO2_MIN_SAMPLE_RATE and XAUDIO2_MAX_SAMPLE_RATE. Note Data formats such as XMA, {{ADPCM}}, and {{xWMA}} that require more information than provided by have a structure as the first member in their format structure. When creating a source voice with one of those formats cast the format's structure as a structure and use it as the value for pSourceFormat. + [in] Flags that specify the behavior of the source voice. A flag can be 0 or a combination of one or more of the following: ValueDescriptionXAUDIO2_VOICE_NOPITCHNo pitch control is available on the voice.?XAUDIO2_VOICE_NOSRCNo sample rate conversion is available on the voice, the voice's outputs must have the same sample rate.Note The XAUDIO2_VOICE_NOSRC flag causes the voice to behave as though the XAUDIO2_VOICE_NOPITCH flag also is specified. ?XAUDIO2_VOICE_USEFILTERThe filter effect should be available on this voice.?XAUDIO2_VOICE_MUSICThe voice is used to play background music. The system automatically can replace the voice with music selected by the user.? + No documentation. + HRESULT IXAudio2::CreateSourceVoice([Out] IXAudio2SourceVoice** ppSourceVoice,[In] const WAVEFORMATEX* pSourceFormat,[None] UINT32 Flags,[None] float MaxFrequencyRatio,[In, Optional] IXAudio2VoiceCallback* pCallback,[In, Optional] const XAUDIO2_VOICE_SENDS* pSendList,[In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + Creates and configures a source voice. + + an instance of + [in] Pointer to a structure. This structure contains the expected format for all audio buffers submitted to the source voice. XAudio2 supports voice types of PCM, xWMA, ADPCM (Windows only), and XMA (Xbox 360 only). XAudio2 supports the following PCM formats. 8-bit (unsigned) integer PCM 16-bit integer PCM (Optimal format for XAudio2) 20-bit integer PCM (either in 24 or 32 bit containers) 24-bit integer PCM (either in 24 or 32 bit containers) 32-bit integer PCM 32-bit float PCM (Preferred format after 16-bit integer) The number of channels in a source voice must be less than or equal to XAUDIO2_MAX_AUDIO_CHANNELS. The sample rate of a source voice must be between XAUDIO2_MIN_SAMPLE_RATE and XAUDIO2_MAX_SAMPLE_RATE. Note Data formats such as XMA, {{ADPCM}}, and {{xWMA}} that require more information than provided by have a structure as the first member in their format structure. When creating a source voice with one of those formats cast the format's structure as a structure and use it as the value for pSourceFormat. + [in] Flags that specify the behavior of the source voice. A flag can be 0 or a combination of one or more of the following: ValueDescriptionXAUDIO2_VOICE_NOPITCHNo pitch control is available on the voice.?XAUDIO2_VOICE_NOSRCNo sample rate conversion is available on the voice, the voice's outputs must have the same sample rate.Note The XAUDIO2_VOICE_NOSRC flag causes the voice to behave as though the XAUDIO2_VOICE_NOPITCH flag also is specified. ?XAUDIO2_VOICE_USEFILTERThe filter effect should be available on this voice.?XAUDIO2_VOICE_MUSICThe voice is used to play background music. The system automatically can replace the voice with music selected by the user.? + [in] Highest allowable frequency ratio that can be set on this voice. The value for this argument must be between XAUDIO2_MIN_FREQ_RATIO and XAUDIO2_MAX_FREQ_RATIO. Subsequent calls to are clamped between XAUDIO2_MIN_FREQ_RATIO and MaxFrequencyRatio. The maximum value for this argument is defined as XAUDIO2_MAX_FREQ_RATIO, which allows pitch to be raised by up to 10 octaves. If MaxFrequencyRatio is less than 1.0, the voice will use that ratio immediately after being created (rather than the default of 1.0). Xbox 360 For XMA voices there is an additional restriction on the MaxFrequencyRatio argument and the voice's sample rate. The product of these two numbers cannot exceed XAUDIO2_MAX_RATIO_TIMES_RATE_XMA_MONO for one-channel voices or XAUDIO2_MAX_RATIO_TIMES_RATE_XMA_MULTICHANNEL for voices with any other number of channels. If the value specified for MaxFrequencyRatio is too high for the specified format, the call to CreateSourceVoice fails and produces a debug message. Note XAudio2's memory usage can be reduced by using the lowest possible MaxFrequencyRatio value. + No documentation. + HRESULT IXAudio2::CreateSourceVoice([Out] IXAudio2SourceVoice** ppSourceVoice,[In] const WAVEFORMATEX* pSourceFormat,[None] UINT32 Flags,[None] float MaxFrequencyRatio,[In, Optional] IXAudio2VoiceCallback* pCallback,[In, Optional] const XAUDIO2_VOICE_SENDS* pSendList,[In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + Creates and configures a source voice. + + an instance of + [in] Pointer to a structure. This structure contains the expected format for all audio buffers submitted to the source voice. XAudio2 supports voice types of PCM, xWMA, ADPCM (Windows only), and XMA (Xbox 360 only). XAudio2 supports the following PCM formats. 8-bit (unsigned) integer PCM 16-bit integer PCM (Optimal format for XAudio2) 20-bit integer PCM (either in 24 or 32 bit containers) 24-bit integer PCM (either in 24 or 32 bit containers) 32-bit integer PCM 32-bit float PCM (Preferred format after 16-bit integer) The number of channels in a source voice must be less than or equal to XAUDIO2_MAX_AUDIO_CHANNELS. The sample rate of a source voice must be between XAUDIO2_MIN_SAMPLE_RATE and XAUDIO2_MAX_SAMPLE_RATE. Note Data formats such as XMA, {{ADPCM}}, and {{xWMA}} that require more information than provided by have a structure as the first member in their format structure. When creating a source voice with one of those formats cast the format's structure as a structure and use it as the value for pSourceFormat. + [in] Flags that specify the behavior of the source voice. A flag can be 0 or a combination of one or more of the following: ValueDescriptionXAUDIO2_VOICE_NOPITCHNo pitch control is available on the voice.?XAUDIO2_VOICE_NOSRCNo sample rate conversion is available on the voice, the voice's outputs must have the same sample rate.Note The XAUDIO2_VOICE_NOSRC flag causes the voice to behave as though the XAUDIO2_VOICE_NOPITCH flag also is specified. ?XAUDIO2_VOICE_USEFILTERThe filter effect should be available on this voice.?XAUDIO2_VOICE_MUSICThe voice is used to play background music. The system automatically can replace the voice with music selected by the user.? + [in] Highest allowable frequency ratio that can be set on this voice. The value for this argument must be between XAUDIO2_MIN_FREQ_RATIO and XAUDIO2_MAX_FREQ_RATIO. Subsequent calls to are clamped between XAUDIO2_MIN_FREQ_RATIO and MaxFrequencyRatio. The maximum value for this argument is defined as XAUDIO2_MAX_FREQ_RATIO, which allows pitch to be raised by up to 10 octaves. If MaxFrequencyRatio is less than 1.0, the voice will use that ratio immediately after being created (rather than the default of 1.0). Xbox 360 For XMA voices there is an additional restriction on the MaxFrequencyRatio argument and the voice's sample rate. The product of these two numbers cannot exceed XAUDIO2_MAX_RATIO_TIMES_RATE_XMA_MONO for one-channel voices or XAUDIO2_MAX_RATIO_TIMES_RATE_XMA_MULTICHANNEL for voices with any other number of channels. If the value specified for MaxFrequencyRatio is too high for the specified format, the call to CreateSourceVoice fails and produces a debug message. Note XAudio2's memory usage can be reduced by using the lowest possible MaxFrequencyRatio value. + [in, optional] Pointer to a client-provided callback interface, . + No documentation. + HRESULT IXAudio2::CreateSourceVoice([Out] IXAudio2SourceVoice** ppSourceVoice,[In] const WAVEFORMATEX* pSourceFormat,[None] UINT32 Flags,[None] float MaxFrequencyRatio,[In, Optional] IXAudio2VoiceCallback* pCallback,[In, Optional] const XAUDIO2_VOICE_SENDS* pSendList,[In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + Starts consumption and processing of audio by the voice. Delivers the result to any connected submix or mastering voices, or to the output device, with CommitNow changes. + + No documentation. + HRESULT IXAudio2SourceVoice::Start([None] UINT32 Flags,[None] UINT32 OperationSet) + + + + Starts consumption and processing of audio by the voice. Delivers the result to any connected submix or mastering voices, or to the output device. + + [in] Identifies this call as part of a deferred batch. See the {{XAudio2 Operation Sets}} overview for more information. + No documentation. + HRESULT IXAudio2SourceVoice::Start([None] UINT32 Flags,[None] UINT32 OperationSet) + + + + Returns the voice's current cursor position data. + + void IXAudio2SourceVoice::GetState([Out] XAUDIO2_VOICE_STATE* pVoiceState) + + + + Returns the frequency adjustment ratio of the voice. + + void IXAudio2SourceVoice::GetFrequencyRatio([Out] float* pRatio) + + + + Reconfigures the voice to consume source data at a different sample rate than the rate specified when the voice was created. + + HRESULT IXAudio2SourceVoice::SetSourceSampleRate([None] int NewSourceSampleRate) + + + + A submix voice is used primarily for performance improvements and effects processing. Data buffers cannot be submitted directly to submix voices and will not be audible unless submitted to a mastering voice. A submix voice can be used to ensure that a particular set of voice data is converted to the same format and/or to have a particular effect chain processed on the collective result. + + IXAudio2SubmixVoice + + + + Initializes a new instance of the class. + + The native pointer. + + + + Creates and configures a mastering voice on the default audio device, with stereo channels at 44100Hz. + + an instance of + HRESULT IXAudio2::CreateSubmixVoice([Out] IXAudio2SubmixVoice** ppSubmixVoice,[None] UINT32 InputChannels,[None] UINT32 InputSampleRate,[None] UINT32 Flags,[None] UINT32 DeviceIndex,[In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + Creates and configures a mastering voice on the default audio device and 44100Hz. + + an instance of + [in] Number of channels the mastering voice expects in its input audio. InputChannels must be less than or equal to XAUDIO2_MAX_AUDIO_CHANNELS. InputChannels can be set to XAUDIO2_DEFAULT_CHANNELS, with the default being determined by the current platform. Windows Attempts to detect the system speaker configuration setup. Xbox 360 Defaults to 5.1 surround. + HRESULT IXAudio2::CreateSubmixVoice([Out] IXAudio2SubmixVoice** ppSubmixVoice,[None] UINT32 InputChannels,[None] UINT32 InputSampleRate,[None] UINT32 Flags,[None] UINT32 DeviceIndex,[In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + Creates and configures a mastering voice on the default audio device. + + an instance of + [in] Number of channels the mastering voice expects in its input audio. InputChannels must be less than or equal to XAUDIO2_MAX_AUDIO_CHANNELS. InputChannels can be set to XAUDIO2_DEFAULT_CHANNELS, with the default being determined by the current platform. Windows Attempts to detect the system speaker configuration setup. Xbox 360 Defaults to 5.1 surround. + [in] Sample rate of the input audio data of the mastering voice. This rate must be a multiple of XAUDIO2_QUANTUM_DENOMINATOR. InputSampleRate must be between XAUDIO2_MIN_SAMPLE_RATE and XAUDIO2_MAX_SAMPLE_RATE. InputSampleRate can be set to XAUDIO2_DEFAULT_SAMPLERATE, with the default being determined by the current platform. Windows Windows XP defaults to 44100. Windows Vista and Windows 7 default to the setting specified in the Sound Control Panel. The default for this setting is 44100 (or 48000 if required by the driver). Xbox 360 Defaults to 48000. + HRESULT IXAudio2::CreateSubmixVoice([Out] IXAudio2SubmixVoice** ppSubmixVoice,[None] UINT32 InputChannels,[None] UINT32 InputSampleRate,[None] UINT32 Flags,[None] UINT32 DeviceIndex,[In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + Creates and configures a submix voice. + + an instance of + [in] Number of channels in the input audio data of the submix voice. InputChannels must be less than or equal to XAUDIO2_MAX_AUDIO_CHANNELS. + [in] Sample rate of the input audio data of submix voice. This rate must be a multiple of XAUDIO2_QUANTUM_DENOMINATOR. InputSampleRate must be between XAUDIO2_MIN_SAMPLE_RATE and XAUDIO2_MAX_SAMPLE_RATE. + [in] Flags that specify the behavior of the submix voice. Can be 0 or the following: ValueDescriptionXAUDIO2_VOICE_USEFILTERThe filter effect should be available on this voice.? + [in] An arbitrary number that specifies when this voice is processed with respect to other submix voices, if the XAudio2 engine is running other submix voices. The voice is processed after all other voices that include a smaller ProcessingStage value, and before all other voices that include a larger ProcessingStage value. Voices that include the same ProcessingStage value are processed in any order. A submix voice cannot send to another submix voice with a lower or equal ProcessingStage value; this prevents audio being lost due to a submix cycle. + No documentation. + HRESULT IXAudio2::CreateSubmixVoice([Out] IXAudio2SubmixVoice** ppSubmixVoice,[None] UINT32 InputChannels,[None] UINT32 InputSampleRate,[None] UINT32 Flags,[None] UINT32 ProcessingStage,[In, Optional] const XAUDIO2_VOICE_SENDS* pSendList,[In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + A mastering voice is used to represent the audio output device. Data buffers cannot be submitted directly to mastering voices, but data submitted to other types of voices must be directed to a mastering voice to be heard. + + IXAudio2MasteringVoice + + + + Initializes a new instance of the class. + + The native pointer. + + + + Creates and configures a mastering voice on the default audio device, with stereo channels at 44100Hz. + + an instance of + HRESULT IXAudio2::CreateMasteringVoice([Out] IXAudio2MasteringVoice** ppMasteringVoice,[None] UINT32 InputChannels,[None] UINT32 InputSampleRate,[None] UINT32 Flags,[None] UINT32 DeviceIndex,[In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + Creates and configures a mastering voice on the default audio device and 44100Hz. + + an instance of + [in] Number of channels the mastering voice expects in its input audio. InputChannels must be less than or equal to XAUDIO2_MAX_AUDIO_CHANNELS. InputChannels can be set to XAUDIO2_DEFAULT_CHANNELS, with the default being determined by the current platform. Windows Attempts to detect the system speaker configuration setup. Xbox 360 Defaults to 5.1 surround. + HRESULT IXAudio2::CreateMasteringVoice([Out] IXAudio2MasteringVoice** ppMasteringVoice,[None] UINT32 InputChannels,[None] UINT32 InputSampleRate,[None] UINT32 Flags,[None] UINT32 DeviceIndex,[In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + Creates and configures a mastering voice on the default audio device. + + an instance of + [in] Number of channels the mastering voice expects in its input audio. InputChannels must be less than or equal to XAUDIO2_MAX_AUDIO_CHANNELS. InputChannels can be set to XAUDIO2_DEFAULT_CHANNELS, with the default being determined by the current platform. Windows Attempts to detect the system speaker configuration setup. Xbox 360 Defaults to 5.1 surround. + [in] Sample rate of the input audio data of the mastering voice. This rate must be a multiple of XAUDIO2_QUANTUM_DENOMINATOR. InputSampleRate must be between XAUDIO2_MIN_SAMPLE_RATE and XAUDIO2_MAX_SAMPLE_RATE. InputSampleRate can be set to XAUDIO2_DEFAULT_SAMPLERATE, with the default being determined by the current platform. Windows Windows XP defaults to 44100. Windows Vista and Windows 7 default to the setting specified in the Sound Control Panel. The default for this setting is 44100 (or 48000 if required by the driver). Xbox 360 Defaults to 48000. + HRESULT IXAudio2::CreateMasteringVoice([Out] IXAudio2MasteringVoice** ppMasteringVoice,[None] UINT32 InputChannels,[None] UINT32 InputSampleRate,[None] UINT32 Flags,[None] UINT32 DeviceIndex,[In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + Creates and configures a mastering voice. + + an instance of + [in] Number of channels the mastering voice expects in its input audio. InputChannels must be less than or equal to XAUDIO2_MAX_AUDIO_CHANNELS. InputChannels can be set to XAUDIO2_DEFAULT_CHANNELS, with the default being determined by the current platform. Windows Attempts to detect the system speaker configuration setup. Xbox 360 Defaults to 5.1 surround. + [in] Sample rate of the input audio data of the mastering voice. This rate must be a multiple of XAUDIO2_QUANTUM_DENOMINATOR. InputSampleRate must be between XAUDIO2_MIN_SAMPLE_RATE and XAUDIO2_MAX_SAMPLE_RATE. InputSampleRate can be set to XAUDIO2_DEFAULT_SAMPLERATE, with the default being determined by the current platform. Windows Windows XP defaults to 44100. Windows Vista and Windows 7 default to the setting specified in the Sound Control Panel. The default for this setting is 44100 (or 48000 if required by the driver). Xbox 360 Defaults to 48000. + [in] Index of the output device that will be sent input by the mastering voice. Specifying the default value of 0 causes XAudio2 to select the global default audio device. + HRESULT IXAudio2::CreateMasteringVoice([Out] IXAudio2MasteringVoice** ppMasteringVoice,[None] UINT32 InputChannels,[None] UINT32 InputSampleRate,[None] UINT32 Flags,[None] UINT32 DeviceIndex,[In, Optional] const XAUDIO2_EFFECT_CHAIN* pEffectChain) + + + + The IXAudio2VoiceCallback interface contains methods that notify the client when certain events happen in a given . This interface should be implemented by the XAudio2 client. XAudio2 calls these methods through an interface reference provided by the client in the method. Methods in this interface return void, rather than an HRESULT. + + IXAudio2VoiceCallback + + + + Called during each processing pass for each voice, just before XAudio2 reads data from the voice's buffer queue. + + The number of bytes that must be submitted immediately to avoid starvation. This allows the implementation of just-in-time streaming scenarios; the client can keep the absolute minimum data queued on the voice at all times, and pass it fresh data just before the data is required. This model provides the lowest possible latency attainable with XAudio2. For xWMA and XMA data BytesRequired will always be zero, since the concept of a frame of xWMA or XMA data is meaningless. Note In a situation where there is always plenty of data available on the source voice, BytesRequired should always report zero, because it doesn't need any samples immediately to avoid glitching. + void IXAudio2VoiceCallback::OnVoiceProcessingPassStart([None] UINT32 BytesRequired) + + + + Called just after the processing pass for the voice ends. + + void IXAudio2VoiceCallback::OnVoiceProcessingPassEnd() + + + + Called when the voice has just finished playing a contiguous audio stream. + + void IXAudio2VoiceCallback::OnStreamEnd() + + + + Called when the voice is about to start processing a new audio buffer. + + Context pointer that was assigned to the pContext member of the structure when the buffer was submitted. + void IXAudio2VoiceCallback::OnBufferStart([None] void* pBufferContext) + + + + Called when the voice finishes processing a buffer. + + Context pointer assigned to the pContext member of the structure when the buffer was submitted. + void IXAudio2VoiceCallback::OnBufferEnd([None] void* pBufferContext) + + + + Called when the voice reaches the end position of a loop. + + Context pointer that was assigned to the pContext member of the structure when the buffer was submitted. + void IXAudio2VoiceCallback::OnLoopEnd([None] void* pBufferContext) + + + + Called when a critical error occurs during voice processing. + + Context pointer that was assigned to the pContext member of the structure when the buffer was submitted. + The HRESULT code of the error encountered. + void IXAudio2VoiceCallback::OnVoiceError([None] void* pBufferContext,[None] HRESULT Error) + + + + Provides information about an audio device. + + XAUDIO2_DEVICE_DETAILS + + + + String identifier for the audio device. + + wchar_t DeviceID[256] + + + + Friendly name, which is suitable for display to the user. + + wchar_t DisplayName[256] + + + + Roles are assigned by the user, and specify which audio scenarios use the device as a default device. See the enumeration for details. + + XAUDIO2_DEVICE_ROLE Role + + + + structure that describes the device's native PCM audio format. + + WAVEFORMATEXTENSIBLE OutputFormat + + + + No documentation. + + XAUDIO2_VOICE_DETAILS + + + + No documentation. + + int CreationFlags + + + + No documentation. + + int InputChannels + + + + No documentation. + + int InputSampleRate + + + + Defines a destination voice that is the target of a send from another voice and specifies whether a filter should be used. + + XAUDIO2_SEND_DESCRIPTOR + + + + Indicates whether a filter should be used on data sent to the voice pointed to by pOutputVoice. Flags can be 0 or XAUDIO2_SEND_USEFILTER. + + XAUDIO2_VOICE_SEND_FLAGS Flags + + + + A reference to an that will be the target of the send. The pOutputVoice member cannot be NULL. + + IXAudio2Voice* pOutputVoice + + + + Initializes a new instance of the struct. + + The output voice. + + + + Initializes a new instance of the struct. + + The send flags. + The output voice. + + + + Gets or sets the output voice. This parameter cannot be null. + + The output voice. + + + + No documentation. + + XAUDIO2_VOICE_SENDS + + + + No documentation. + + int SendCount + + + + No documentation. + + XAUDIO2_SEND_DESCRIPTOR* pSends + + + + No documentation. + + XAUDIO2_EFFECT_CHAIN + + + + No documentation. + + int EffectCount + + + + No documentation. + + XAUDIO2_EFFECT_DESCRIPTOR* pEffectDescriptors + + + + No documentation. + + XAUDIO2_FILTER_PARAMETERS + + + + No documentation. + + XAUDIO2_FILTER_TYPE Type + + + + No documentation. + + float Frequency + + + + No documentation. + + float OneOverQ + + + + Used with when submitting xWMA data. + + XAUDIO2_BUFFER_WMA + + + + Decoded packet cumulative data size array, each element is the number of bytes accumulated after the corresponding xWMA packet is decoded in order, must have PacketCount elements. + + const int* pDecodedPacketCumulativeBytes + + + + Number of xWMA packets submitted, must be >= 1 and divide evenly into the respective {{XAUDIO2_BUFFER.AudioBytes}} value passed to . + + int PacketCount + + + + No documentation. + + XAUDIO2_VOICE_STATE + + + + No documentation. + + void* pCurrentBufferContext + + + + No documentation. + + int BuffersQueued + + + + No documentation. + + __int64 SamplesPlayed + + + + No documentation. + + XAUDIO2_PERFORMANCE_DATA + + + + No documentation. + + __int64 AudioCyclesSinceLastQuery + + + + No documentation. + + __int64 TotalCyclesSinceLastQuery + + + + No documentation. + + int MinimumCyclesPerQuantum + + + + No documentation. + + int MaximumCyclesPerQuantum + + + + No documentation. + + int MemoryUsageInBytes + + + + No documentation. + + int CurrentLatencyInSamples + + + + No documentation. + + int GlitchesSinceEngineStarted + + + + No documentation. + + int ActiveSourceVoiceCount + + + + No documentation. + + int TotalSourceVoiceCount + + + + No documentation. + + int ActiveSubmixVoiceCount + + + + No documentation. + + int ActiveResamplerCount + + + + No documentation. + + int ActiveMatrixMixCount + + + + No documentation. + + int ActiveXmaSourceVoices + + + + No documentation. + + int ActiveXmaStreams + + + + No documentation. + + XAUDIO2_DEBUG_CONFIGURATION + + + + No documentation. + + int TraceMask + + + + No documentation. + + int BreakMask + + + + No documentation. + + BOOL LogThreadID + + + + No documentation. + + BOOL LogFileline + + + + No documentation. + + BOOL LogFunctionName + + + + No documentation. + + BOOL LogTiming + + + + Internal VoiceCallback Callback Impl + + + + + A Reverb XAudio2 AudioProcessor. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + + + + A VolumeMeter XAudio2 AudioProcessor. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + + + diff --git a/Libs/SharpDX.dll b/Libs/SharpDX.dll new file mode 100644 index 0000000000000000000000000000000000000000..2ac6b3e489fa526085fe3f0db1db3b63f4e9ce52 GIT binary patch literal 181760 zcmeFa3z%h9buPMUt+m&F)UL;_4ZEtkkt)$9%c_3SO?M+IU7~`ZfQrGrcc~y!Dl}S9 z1ty`onnn|om_`y`>2M-JP9V{k#Kf3~##fF}(WofVlc$Gx6Te(@l6XCN+<4Dz?*ET5 z=2~;@y{ozblY77Wo&8m2!a^@k3Jd%zl%G63v%83 zaum^{GanfZeyjS$C;#ry3%~f}m%i@$)!Ca?mS4N_s@KoH`c-du!}2Y&*DlSj-1>&u z>)$Z@+$*k}ef{!vOFKtKYEL!RFM3`Oyl^NA&VT*OFLSv)5`<449;yVv$HO2<6#L4* zKzP=rSkN#~l$$?y4`xvs;Q5P!g&zxoarw*d25OR^0=`!={D{ZQ;`9~;^#Xi~z-$np z1lg|w`1u(W1Uqk8`r%suU-$b~E|%5gcF90;&CZq8l~)tN0y-H#SxmSP1PeP?mTp`| zLY38Y@aevE7m}6#TcBR?qikVN3TEFm6#VT)L&1<>AN!@bI}CmhWT0=vwd8pen>mc( z{|x*;760?Q!YI8X43hOS$~6bzM?D}z{$!3k3siwdAOMPZ(IDpcY~YYbBU~fD8=nI3 zn*Zy`(+eqts2!>$XZ`uuC7;|U_Xii+wfS+uEbOoF{@_BV7Mdg=B)_==KS}e7S|WTA z69nfPVcR3zqnW2a2BAs6zfi;=aPe>T;`35#zUPAuHD~2WnG`}xj?Lu86h*8Z8cxa` zpl-UbI|md}*ACT_ibIi46l@0x^j_p+iHFOPkT14}!?LG$mix7!EA`T8{%7~+U$2-* zBbBPl--*feds{;!HerIZ3 z%$*fRna%81+*!*LZ$5t!6?A?WNw{k%T>ZSos~?6PgY%6Z26OPl&>ZN+*l1b{MfgF1 z-w@s$!Yb1zp?EGODO*VVR;A4iYX4})4Qb-J)?DyL59386Gl}-%FIn*7k-5fSPP09z zOgdAmXbH(2ahEIa-GK*Sy!lH0jqI2X~bd+_@mzFSP+wk(4l zyc4At-`ybnqQmbIJ9H4*la#LrU$RhyAN1ghit@3_dds4fgEID}jght&M}76^;zY#C z?bp$XlHqG0y1?XEGEsZ<^L^Kw?;oQb;pAL&EA4W}_zFzorWLr(n^sZhwcDcmiI>W* z=`Goh17MBEvH>87g6%KAnY%A7j?RRhr+8DN0zIee}^sZ@=Lc*Q1at zS|{5lOlMLPsyNa41@L1ia2&?#C`vrn+#Lr$hw1~aaps*@Kp!aiUA%{fnQm<~MB>9t zyEc{w#}Qopr8r3LVA5pLC?we_QB3tyNOl|NG2JiKNhr4TQ+VYN;+}GB?U(8#6le5P zcv20@<4OHeorFSdHwsYIV)Icr5u|U@ws3X?6Y|4vR{U8}n7&nm0s5}=m>0g&3;(ni z{uwX)b_>(SZ$!ROLnGWV%<ftVn?& z^4E}ZV#vWm>BE34lkIvXeB1SVz8)pz)n_5sJJ5xMu*)cT&3{O~mMxSV?JfmSpZucm zFw|}4zlH+G9m9x)7BDoTP%+Xbq=EG_X!kL2n4Cdd8PMqF;IB#n>Vfs%n82tvmk5qu zL~=OF)Qclihs(tp$frGkPlogOc+$}ie_UNeB#t7MtJJZ&i%6VCELW*&snh*d9^^=? z9~+X}ghE1%7#1Hfydj1+VZb~wu82}h3K-tw!qz8JUkl(5)o8!4ax<)TD)Z-()rl58 zmN@ok||0V_r zt+{AV`ff!pwIg$ z4a&T(l)gkidbDpPxE@OX58!HNfh?%EM&{3eL#!%6oc|+PN0H=U6YhDg=~ibWgQD3?2-!0 zHu^r`QNl*FCbccs^zW%Ar2AFeht-?bBk^*W6Sm6-&c@8Jd|)IFZ^jTayn~myYDG|y zhvFRf=)v-0`W^6T#+9XVwUdrPoy}6ETy3XV!KpP$oHjz*W&*!W85(f|)5*3FrGE!X zQ9O`dc_Nm@$}=_uNioG0^{Y?12@vW+d=kT+PvTrW_et+9`Xpvw@IUZLwEnaKN!>_O z$F4mV~MJy^{_>a7>w`oUN z@I|7M38aD-x?3v^(*!C{ebBg?3~)?|xf4daMgK#69plCKKLT6TNq@U5l=Y=Xd^5X= zNUmy|rC!W%*o(pHN%}ch&q!JC%~+a6u&>pKX>q~6kXjYO*vjj5~7R{vW zLgj`o+#F~&5F`tw5Ej)&xeMEkyPamGQPE8HYOV+7jd0&t)hd=s7MoRracBke{7l#RwnqtR_nG%CC`orp%`p z8ZP3q&~Xy3eHLJ6*lNBUt}$B0pw}}FY~xXYH6E@qH!yr;KMNilC8N_22OP@?32p{s z)hM_Scm8as8K)mY(m4HfUbl&DYNHTgC6^2>4Tp}-Wlnw{oZkxCAXl3bNthC{Bs7$McpRm#F(o-3h9J6x|HHjGCqIWV#0s_Zfx za_z-{6f3JTz@Qzmj;@9NOPT(C&1$dDO4vWE0l8VV}aWIew_yR>jgr0rdqDx zy(Ab#aQxtpJuCy!pvz5lChB3ZGm=!R%I>?7BL(OfMr9 zwvQ;-RZK4fx+0Mdl-dJmF9R(`67We6nNOmVKwe*=4`OFEoFsBT>thGrvaeIuK4gEb zEUj@rhUuu^N@qm-lyd=3W_E){i!K?w$t;p9 zHxmOWOS3!?Xp#y7EI_l0fJD_Qu!u$t{UrKrGywF4rEUW@T_K{{?NkZZx*ZNlnWEFg zIGp;mObrmO@QV_onLc*T^~P{{5uJ4%S3EYLG8-di8rkrmITmTmXrxAy$Ba*mi&PV1 za`Wn7_kKiCMnv`0;O?!6qQr>e&7<1y*Ia8ZZj4zSs-NOI6#Lgm`d2MG3{5&&&qAs? z*18H)PfN&xO$7Kx2PM`d-XEs9yV)RrA%z+2d9+n5NI ztF;h-Le{p10+@-rm=sIh?4OYPzH@7%S@oj!jvlNoHsgtsy0?DqxCrttsMkgG=}A?b zNvGP)rBlsj(%~s22j9GjE$zWTTg2M$$vIJ;FgEH0x&TcRQfAXRQ+WzvDzy&Pgz1{8 z3@yX}d579O9b3gpy0S+2)n7JU`}JQoeRCSY61myLo;pfcY4;auNX0PrWB zys^Jh!Bnx{h)3c|e7W@eS7C<6Ws6#Td9pwEOI|H{C3vQB6f4h%uzR)^@RC21Jm)9q zNTnL!Bym4_(Br$vj!jCzv>t~JdM5UB8K2%bOwStS{je7pPZ>?3(k!DBa|LRYH!Bg1 zWk89DHfb2lN~Cy^gu#tV#8^yxJsu`CBRc4Co3+BoFCS1aZn#lv45LJ~Cc4UItx<0d z#|>18R#9VkV2Nye6bFTV<4upJ--u*g&l|tFvEN36I2{P;wVMs*8a9~A?Wi!O%h7Rp zscMshPS!n^%~S@L>qj47xpugAK4`9t5wln)9|>!S*@WWr;b`VmPR!Mt;a-LjZd6@5u6g%t7YgA<=^kOwg%Ju95DAJeVWH-=%MXCTm#4=Y2RV$-SOT?yZ$4_u@I(UMgcprM#n5;j%ik z!ScKYbGIqb?vz@v1ASzZ9qO_lY{&WF9 zNk7ABWVzsb+y)k|_w!j7ZB$p3v}0d^kz*E0)yZ-rc3Ak;Lfz?nxT~C~_muh~A5pDl zhY7tfQBgz^Jf2V*>iLbJ;m_Bzw2^(UvNE%;))DoA%YEI-7-`=#JYDJl@<3{-M4w`M z`%d@trz7?QuqJM}pbT?pqbfsIkzVz3oFOJFg5*s?YfdP%t|bwJ8AXo`coZU=vSl!% zP<+-XJnPWhGeP#<=Cw{wQ~R#67AdKnWCq?eb5^nJ?BhU zLvN4Q{(4I$Cev0+mioUi0(TGg%BYsrx$v*VZn8S_stN0Aw9w~#LQ-TEVs{K;Oi`sJs0g0kPPk0h)$vN3B5 zvj)g2k-bB1jeDAHP#>MLzj}xDSG@Q1R~*I5L)h)%l;aTvFTh+_>Qx`hvNtPaILzg4 zdIqT|uc_EX$;I}VzfF)_Y>%nC$!Gd&C|`L$>m#skapACpVw zxdxU+WMCEjyVlG1E0@hRcIvrEN_yJIQ7@b1B6H_3IFH^)`bRb%>k&TBwcEm|b=-29Jgy=}Q^!?2j?1|Y0bMjA zymtV1MZIzl9G}ev^QVVvqKa^h5K zs--!=gIUQ~pU?ldLMBlF>Xf9SukP!yV}ha>R9A@%8mTt%$hC6jwQb(ZGvgXaW~MYS zcdfEg7D_4`#-LWo_o=w!eT&BQozTFL?2KjB_hS2$9d$sF&E3=E#M%!cbp@~ zGcs;L@D0B6fb||psOoYU%A(qG7>Z-c`fVYz4EW&v=s^=d10=Odt>ZWBo3eLMC{-K}oe`Hf^fws%;~V z!kKX^&_NuLh@&iKY+#m0)f*u0fn z>%of6IIrBQb}KgH@^Y7CU5lbop2sSeDF+3o@i2UCtUD1$m0!OVM9g$Peqk-W1c zGHF@0+`B7!pU0q>+4Z-0reLv|g7H0~zoFKr{TVix$(XrQixD4{hWi-guxsBuuL&pb%oHhb)Fb7Q=kA7y@i-N$@=5 zt*ot1UAheEv(1n`$E-fN?(jllE~7Ml>ja$0bC|lqMp90 z$J7V+jeJL_hwha6xZ6yyC6k|binC<0yv15x*tM1>0j3DEe&$sAq8`~?uVqYK-(`)~ zILrR;FR_Mn-$GP^Hr8P#&P(H8wakqamcEL zJ~Ldsn=EKo7ox5)p0+*aAH#reI@@C|ZQ>ZmN!$T0#$%9;kqokJ*RY*(aGmkfedg?( z{C%B8{)bt%!X8fS>tsO-I4mi#ItsXa?>Wb$ls{T2@_szB(L6-8hnP?It0~qs>|L`cxCHWXY%vj>IGqgn?nR1+ z4>f<5BS<^}$dF_!NGzFVNOBih=xext2y>D~h#x0ucs?YPG|Wxn^0xXq#x!{D0L{U- zVxl7<%q)n;T#c#1(O9VFg0FMVHU%@+XaLg$BoTlu1jwJswh~abc=rPcnd=E#05aEe zbTZcyI-}tH3~$%T5A(gLo|zrF4wwcC@4jiEWYRMYWL`R^QoS>yzIoslHxK+D*(6Qo zftow!ftnxYfttnianlmVieYdOc)Gb9=E#LPA!;y~KO7Ls>ihvSN`8qy<^AGN!0p*3K!&$}ZlMm7pgp zK~L7sNoDQ!%i8Uiwc9Ui_Y`DhAMeRZ(36#*Cu`Tq`YotQD!wRNQLLgwnK17MPo=f2 zWsb~DB_OJH8L|H8!})VlV$y2$ISl33+H)9k)5>!gvd!!6+h}AmP7!7f5IznN77h?< zD?G;^pN2f>PpoZoUQI?euV#?*YTj*LEhudmoL4g=n^!Z)2Y0;NyjoD&WH_&;AU3aN zu#TAn?>4U%ls2Z3YAlttJF0RLPMLAQg538IrNI$S!mCo2JMbDd-}BTt_?akAHV6M3 zln69K|$0paA2D)V`z~ z++g{e**J$_AX1wdIoDvIMo7-)BoIMRBP3gM7l1GX`U{Jo zU_I)EOs3Et^&%qIZV+zW_6ukF)LZ+ZxOu>7W{S;aW{S;aW{Ojl`R{X?OTnVE316eIX<0v@ zR1${qt0r9xrO9FlD1^y3rO09k&`*?u7g|1MN6H6)pGAiBxo1e9v04g!E!%%6zE(Kd z8iFuzYY0N<))4$+a;<<=vR1%=tT2#PFj6e0Ap^l^ab!;TO3T+3!L28FIh&okwc>cp%y?cJ$f3?Rw5#6nVlym5(z)Bt&tC6?lQx2(5g zy!h)Y0$URZz6TSO^%d4(zM{h1a)_Db5c9%n3ufb3ZDGGjf60E6Yb|6hD=3%%XDcY= z-M0Y4EczB;m{Z>Z3^U{el>g_4DWwrq%j4ayan;=YhhTS~!;h6hbNDH+$!XvoWQY>Ox0b;wc#{g1bJ@<#1tMs=4J0Q^bGD^9D_ow0jAt`F=UuPC zoxd=h02+%}SXje`gX#9_a{#a78GamwYrHK}DN++*xa~yw3_z<-CTc4#f_f5B+X|>N ziF%qtAyer4xd7*Iwi}s7%g-Z3S;F8WDoPOFjK#a5aE+qKp%$Xu^aoIc?K5Gt%zVx+ zY2ojn+HU^_c9W(PtRJJ5Ht?9qj$m~uKDB&GQWKi{UuU@oI4^438l;aW+v~iA0-$^u zzEi}*mPNT2s~Um}SH>c&T%{=MQA)#lqRl-GcNh=mqFAoP#1pg0bUPB=g6%3>>)~Ny zE9EqV<<*k%-v724-OiKH;VeEh_*l;3lK}Dt4y{~q5&-V3@U-+?llvpCt!~>V3agKu0oSDb9&S@xc9%#a4EHcldMY5h> z3mKtvtLN=@505+@375~uCE9*znC^mpwm(Df%g+FIvQwM?0fm$0XEN zhv@=RM^o+YR5yJ#g65Od7owhPlAyhMA%g3(s6jX|-lS*nU3+Z5@39TH~8MN4`Bg4KA3{q*$`9r7x6KS8cB-pVcGjmM=y;Iwgjq<>v#i z3@C2$u<*dVnG#1Smcmq&Iq(=pHNpJl7cSFF^tX#jMcc&#ejjluxNJuaiPwGs025rh z(qP54*L8Rm?l40|@u|gGxG`U}cM0Oo1mX)Mpm9tsI0*oERmKlJ4f&x{A|udC2zN#Z zjRZhLpZ_x4`3u+P5xpI&YV$*-nQ`!V?~{p328g9;Go z9hvm?$V7h1Vl>`9k6p#mf^s&wA|p{}oF0Tm&Ymwr1Jr03TRtVt01vpB-`x96uCbxK zj1WRJnJ1+xId6@EmltIzeV=5Jx*9F1OgmTLS#Mgs3Oc%tz7-8CfbGGjQa3x2RTv+3 zC`ysTH9RSaA8yy&s4GmQ{CLT!1ivYUqA5F*i#Mz@v5d>e7yX>AU2M$v@)`yPq}p;r zTd2kNDy{najcG64gcfzOX?dRSXs3$#qC4Yz9-Go$in%iW90yNw^>OH8I4;?g$IWPV zq2q97Q3iCeat6z0^&!WrIQp4-#(;V!JsR2O`J**v`Ol2^(PONzIep^O_veq6vpId) zr!VGD{lTkjPLCFp$=_3lq(|f1oF2xR(R(#W{gECfxjFrAkN%8IeKJ-dJ;d9b9z(b+ z{{i(6@iwQ&s4AnMS;z!%^$+njr+=PL@9RGfFuKz|Iz5IiqI5&rhCjF-eFNT1L$z}X zhjNz0Z=e{P=2MIAL``oUHn&l3MO+xz%x~yEFAO{T_|i>a>{jqg;*9u~$3|S$fh8Rr zPRp^^t06n;r_s8hh9^(i)@l@s$CO}8bcBvaX(F8SQVrMWsw0jLZ`d`w@=-d@4&5Ub z&lz*h@XFTM;V`MDj7mNiz|S&D{OtF_HTvMpxeh1=x`@gKs+kKu(nDWRLd02=??g|Q z{-uvG{gsy9HMF_ltDDNRBWleLP4?#!1fSoO?vBf0m6n%l6xc(yISmFIjwW-2b0?vp z_p^L5=XWw1dOSzt9Nx)j=;a)ZYh-gL(E-fL(d7C*2@SoO<>Q>$+{tuJ4`wvZft{3w zUdw1sxqj%WoDQ6$I+@<+og7W3HyqfBhF%p9vCLGFs)>Zvb2`F za3q-DzGOg#q&Z({l%m7&VJPd2h{C)8RT1;(Q{HV}aN0V7@GxpNpB@Ns8FC8O;8bOL z0Bf=70YjplYj4I3r;7Bu;M7iM{fI^v^FNSFO z9DsS8${c`MGtYaRoZf(4<-B2C#G71aspmMhegV?+rzE{YYoS`>Rn0}N{xDw>V3;p# zOUgEQgXQnW_nJu3U`;gS+AGInZe4h5C^jCto=#N}T2QZM}cx!^*V z#s;8fBg`^t%Yah8B^~-YYQ=PY1E=v?rtG&ER?PjZ3zzxlv{k&TpoU@7rt`t zqAZQ|Q($;OhLb*M&Vxmf9xRIVU{Rz8iy}Q(6zRdDNDmf8dax+cgGG@ZEQ-W8S>jd< z2Uu4JSkwo+mH4`WI;0Nu1!b)G#p>vggaLF8mo(F zx;Sfi9h25tIa+@OZ)?2n7%s~LIYs5m`sphXxqdY+ars1Y4eqP2!iB5S^G3=K|J0VR z!)4{87(Maa-dd8r23NGFIQR+V4TUsTUkeP5NLYUz?v-f$dfeh$Q8X;kr8fZJB2;CK z=pDlq6^1~iSC~UUCd)VCI(a9_N2)C)%LTcwI=TFMBp5DNP9$$YV09T6o?$pYcWwL- zsnS_sc2-d-DYR45GwR;$$F<^zAh)0JW|xrthV~ulM^*3X3gb`@XYhVoxVDOWxOR(N zZ^bn_*1)KG`HhT5-;$;KAxZJWa{UpeTfPm~`ZTuCZ--@>H#$)WmXoF)Bt zVR`v>;mo}7Y(uD*k7{OU;=v7uiZ{<@(1CZ&O1oP02Iky)SZ=|Z}m?7ep~x@8i+ zMR;2Y-^|q6JLBm5xaNvJiE4d_?N92fHgzY^L-k54S;27xLf zfWq3<>W?AC`ZL)m!1Mc2_nb$)7rf4geDMx#HF)#MEO`efU2+mjZBC7}_7L5Ph%b$4 zc=Aq&GsFYHT5)c&t>qtwr0;3qh4{)c+DvVv`nKz*b`G!L*pZu7e-en>%28Zx-L3XP zp3Rt;Ngq?<>42*{vHo{VoEGHdb8$Y$Lq#@5V=VFEcyU|e%f%n{41e#?z}r=!sH4f$X!Uw)c&e{TuRnpSp7lDnmoh zB|;PT0e-py&3*gR%X)f0UtDeVigRBho-|x02XL!D1zH)ZqQ5%E@VBU^Mk&*i8rz+S zx}U|0)zUJ!pl};gipep|_IVBJ!Lw)fA8OCjkI9~=l9gQ$%D4K=#GgeI|9;u`haoQt z@PzEU+$ayS@3L>-(~sG{Y4KCO#p5tNe%5PsKW$z*X0!R59*fN{+y$!At)zcCd`gg; zmbBTymOovveA2G{QjdA7`5x zTi>+b`pVk+8s*gs*#1}n>}T2MeBd#)zxRWxbSvqf{tF1^Cc8=d+frzMq+J7>0X>gI z{Yp=iwm*sbKu^@PG);;6)t;yUP4lC<=pUr$q!TOL^4OZ@bYAGZoxZB9yW^~#icDD{ zwVetsE1kAe!DYn)Zn|{8;Ii^;&~{7NJ6BJv?Z(=C^0r*C4{OWPkQn}cwIyU1fa$5V zB^!s~1CfK;P6@}9%Q&oFdE51qg|_oh6@w9}VKL4quDDSdBSt3TYC40~&`?Ws?cpCF z+o_MiURJu5BaQ7>^kg=;C(?wen0^{#c8>YXUxzc}cXCQFT*k=$K+*A*F|t3{ zgThGY;vN({_7y#-Ey>EudQe-Fm8*MDXCy1H?Lj>$Sy}EuotdosP!DRRnylR3i>oCo zKi-QQPFC*f#nqFQpY6qsBrCtriyKW=eyJBXmaP1G4{nw7ob>lO8HJru*O*QO3($4X zn7?!@wZ8qj(*3;S%;9`Cymu_ZHpcWfVL3cWb{^;Edc*QPd3EJBIWx|KP3PUHVif0? z3w{5PTE@ZHh#~Lraf;O73PMttFRi|foe1SZA-HaF7wqNP(w_a{I3H{?(Zo=!wjy4J z_PYK#xND-tUUKwrlLpl0Oh88=@(O)*S z*iw#u$k1X=Ir=Mx7K_T!Up2HCRgQkx&|+6P`i~7Qrj?_=W@xdl9Q}1ei-G0n{|a=u z<|>Ewbu;SHYs=3=g`~4E!dkc`Z^}KBbT;LlNqV_|Qd909eCa&CVBc>+{ud6iZ%VTL z)usD+A7tM@7Y(%Ua~{fyklXi`e)A^z0P{X2`@R#j$CwT5o9{eyPzL@s?rUk){&Z8} zU2OeX<@kLq<5%&~v@9F(1usAzUR_~i&<0os&lyw)%z<^l`=B~_C7$aH z@G<8+l!=zt!Bl@8ko@u1!OK8Oxh28>r-}{zesRvu{Jo`i6WPoO?*It32pj9aI-k+pZp9R{g%760sh5A5;$?+^8P1 zqU7~3-CqwRf4ueZKI)R$NLx6SIpd%z@#l>u@&3z@l!9#>*znuPhB*qZYT-s zhW9~rQ!Q=KMzSL0bu++Ek^J%2O$gd!%;w+MPx0k`mreeT#QF>25a)u+?Kxef+g}BV z=Nooktzf9YXSRf8Pa8zVSaTI$S=9H8&IUXTy~~q?mEVEK%wJIuD)*j38BGhsJSXEE zqltEu3vUh;sSh*HD7_1G`RDeq?k)KArE)7gQ7zY z-EVv`WS_jVi58BXEO+s~@(C0oeKC|KyY&rwvqb$3qpn2M(RYaUSe{tUNP0f_$QFNW z2;PST6Tu@#m`0TLv`eTVz85kaCHX5EJ1WU4K6RbU51sa6>>K3!BC<#D!j+)}i=rtC zbM&2-58pv)*tip8eQrkOa}e%9mFGX(pwlNK7k!aMua`|feBunqy|vrE>}i)$geQSz z&Bm^=d?OouR*_~)FU`3SOKJG5_+`k4zc5<+S%~HpWT}XqZ$NQ2J zQ%w49VDwo&#-j4WE10C;j!)n4&I4_0^ZFviIx|N+i5Sm&A)fqctNeDU2obMK2LBLx zaziKFDJ&R$(Cx|0St3l`}`xZEqBB*nv`J>RrC(epPhGg_wRr%XXBlwtY!DyO`6FrtSRZIV%Q z`|(O3g^~=QfQt;qdtgM%$Lsk`djc8G-f?7`*aF!@=6|!uD)U>u%v6E`QW&GQ;ZV-! zyIgFCoNCE*cWN&jv4i-hGXvkz56Z$88U2I%tAiG$A&q zFd=Zfxs<(UAnk$x$9TyUf^YK*e6C2YXTEYd9OdNFH+JN|54Slv3s&%v;v>Urxu4;c zn_(?C>;F8I3pRi=;mOAgJp@15#vD9U(w_UauFglYMz2NP7Os&rlB=SiCbEy@ znic+ElomQ6UrqS~N(>x%C=R+KHE_IT9AQ z@P;kwzl!@D-urTLkenX9jBe+7gCC6hszSadi&p%DdD464@=~E?YdCnD3@#QNha~Nmf0Z2c9!3lTWx-;#)39DPop|u z-gZeL_@2KMC2H1l$;`~I5kVx$%;dHA%%7$J85~V!W;;L{^~}LNUy;a}8N?pF_#Opj zC8+@i8S~kDr0O(>aS5v^D#gsgp1%|1%xvqPR_(m&P#ww4?fA^$%-`-hAeEK0-lO-~ z0Fl?sLMg#}q>6BI^3Q8PqX3>agEZBd@9tW3G*C!&X=b#8+I#g^dN}!U!uJ}aV1*>r zrOD1$3(OUB-X{X`AKU$0<&R){rgm+Su_22bXGRL_0M5U$I*YOdyUug69%jjCA5f8& z^?zeoEAeRk5 zE?ei6WaGIco@@j?*$8^FDND%qn@(BS{3m+CUBtj$B@n6ajZ@VdgXSa<>g+qa^o(gz+K9{xIwuW zUAY-h3Ri9=!8Zgj*`kh?lr?TlhZ`9$75Ux`Vo7Ukc^-_UHl~_f`{hqV|5u`ID0iNj zMoK#~jX|E7#=D)FCMcDGXQr`w?aVX=d1e~#c4nHOR8pRqMj7nPGzNKQ8t-;ynxM2i zJTr~uvNO{dIMRgm~%{ z@8SSqz?5AJ!xV&=f_L$ZNI`+M1WZAQDR>vBgcOug#bydZOu@V7OZBX4Co`scuT+WI z#y60er%r7yGgE9XGgE9XGgF+Z%-7^He}DblfOC^raa_b=NPe@^v^LW z=5?5P*;zzbNWzjN4*p?|1so3lVL=Nx900^Z6>v_5lAMn=%rVDGF+Wl46DZr&@I%5^ z&M~?Pm3DUAlZ6&3PK(8Huq%p#T`?T2MZo(o!Y0Lf9Okf8hy>fJ2p6UTG>q;!IN|JC z3b}VDK(TJQ?wtWBHZIq_;{Zvnerv!vMy$7Ey!i7-fz52WUj0H^@L4$K`3f~<__jDZ z%jO|TJ&O{gSnR7E{V=k-{kL&BaXMorTdkI~vZKEPTnnH=ze@<9Lcb?aYf_<)0Gh;4 zA?#h^czFvpEuWCRsu90|%kNk;BD^PX;*2sDX|Jy(Cnl4J!?vvFKFP($cQGGQWc4xH^Bozd zo)w-I1i$s1F6$QIKOcK=!G(k1a~Ym#7A?)b@4fArE)CN={9oRGxI3u(d2qzpr0uwh9O0mD5t<)t60sv3)GcyHTaK&X(bnTCd345c z6+L>=anWTMoq1e^k7laJRs3kCc3cY(%?uycB1ALw<5F8VmVD&679*M&J+1|bX2y=Y zqF{cyCc0b`sn$fKHOgcCOMb?>B!i=oGu9g8R4$4<2z`7dnd2*|9bX}Gd`YW(RllkYm7Og5_!ji*lp^|dB@z9SR{3g;seV-(l%|ib zt179tf_|M+gfD58@8=P6HKzJy!TR`0GN%VuRU&Uezob>ZV&!53T4NjNSCTottaYB& zFML^5*;)RkU%cnnTW{G}?)f*}T%E}||E|u)X|5(7-xt(+Qhl-r1NgW)5`7DCz+1U6(nCmdmRJLX^jxg6us`zJk68~r7e;fX{<9{#y&&U6>@&A1MUxELt z@c#<@Ux)ug_@BQ?g~dt@D;GE9z#CPE8;u7y%7+`P1~+Lx`1rg+ta>0tYOM`GVp`e) z0EuR_j^=dD<_|N6rseue$l}(5Se6q0NAQ0-{@E|GOgr$u5C6}?|MT#F8UB9||18fE z{$G#(Tk*e+|MQOG0r~ZYo7B3brN%)JFPD>bzizHsl7>j=-tfka$i?Eh6 z7QaYXOB$@RBY-Ke!Ej;7BUU)ff{SMqk?qJBLFJ|_OXMSK`->BjB!7i}E%FOQGD zl-{olxOToDOOI{#*HUL%Em$;>CLvYT?bMu8WYfsvzDA&f2e|4YSXRVQC0f(?(z;qj z4^Jwo+reXFYE!Ktqtm!1&>AUuxEw69_D=pE5Md znW5j4p;6%I7hg>qFUw1Etrr>02(O++YHO--YM9y#{; zXEam(aMG11LREm*SML%UUX_LoIYa+UhNgc4nut)Yd7-k@@5oZq#In>mn&u2N5usf3 zLS;k3omY0e#qk9+~Ablw5Cj&oCacr9B3 zzDz9TRF;d<42WZK9gbn*SZIf1m^d*G$$U{9J#jR56=+eMK58b?g*q`^5^-~aaJ&`VGA8QFRZT*hu9gKD5t!`M`-rc`qM0 z(GTC7Y*F*PH^EUHw8?uDd^L&2cW?3}?bq&2u;GbjcyBU;^PgyN2%%@D$svS(nEn+Z z^tyB$2%(Rq+dybkod!Z<+8f_1V@Ud3oEIuTGa&2oT;~E#mZp)|%skCkJ+Lj3# zP%K0w*S3tMfYR2+Yg<|yP}{ml=y17wq@i7l=x}6wq+0p6uYTNuI+4& z%f5UB+GAhNXAbDdKZNG7xo$iCy6yDqw$rcMPQPwD{krY+>$cOc+fKi3JN>%t^y{|M zuiH+)Zae+D?ey!m)34jkX1e{buiL*;vt?%`cH1qewOi0=x1h{!L66;n3cCgEbqk8? z7IfAvsH&%H| z%8)q`^*(eZ88Ll9PR!Pv6SF-cXBo#jcS9B+R!2kM!{q8?=sgIjd!ZKqF_S=S-Xd3K zC3a<2V)~h!*viZ#8L^dFiCvkM*p*pxwlXs+BepUtu`9C@yD}@Wm6-sD)h$|?)gihv zt1onARySy6CNd*ty+L70?8>afuFOhoWhOEswlXWRE3*>2GApr_naGUT%B;k$%u4La zti)Dk0w7lRZDm%+?aHh^+m%_}wUwE-jM&Po#IDRr?8>afR%YHZVk@%}yD}@WE3*zPjI4?k-DaD(xT&K4jJwV+LX(bq^Mqnbru zEjpfA^mU_tRA&$1Ma@KV)yV@;R8J(=MPF4qo>}zurCwNP6Cl)f!0V!~xk&V(=<85@_@b}KNX9dZzBVHn&n)^X)$zJ(d;9I}X4g=c38IBeAY;C_>_DiW!b3uijos%IO)H58-t9#qpu2bxy6Uh~fE1 z;zWrC*7YZ>uEPNOlAq0km!uN|z*=6C`UOB!Uy_;yKuceeIt4&OUlMZ%z}j3AYX`u3 zT#_0DKr3I8x&uHXUlLOX!1`K}`T{@`UlKzHz?xc;Is!lgUy|AZK>J>jdI3Q5UXmIC zKLTPbWNY^@@lR<@u+RULjoED}ERq(l?VcZj6Ez?%H+Bt69Fd5lR@CY>EOA64 zj!IJV*RaG9i8$&^+ku89j!4Ai4MM{bMBNB0}D{W62mN+62r;eLf4NDwB#HkzSRl^cT z5OJ(nZE6~pxZIb;!Dv>`_>K*#8vB`L62ZFuXE#3+2fup)Z(QKFCyM9m5}Geb#CRCT zU4#}Eh+V)sWfv!Q`Gdj#WgnvV|3BErADVse8PFrB?p^T7y~||c1h^)}#wotgEo6x= zBtWwkUr2y{L3|+rHd^t81gJ6bg#>8s;tL7TUx+Uxz{V`TkN{hn_(B3~2I30|(2s~O zB)~>4zK{T0p!h-pY#!nZBkKxS)`CCeLOW*K91C284a0cP9M3T58B|Cc)@mu`8HUDD z7{pOP7iViH20A8`K%QZ+{91^Nj#`js7?imuKc(X{49!DeEuC@cG|@1rVmw4pz44)h zYNOh1H?d8Sm6pZgnTAG|5m~m#cnP#*lEo&7t!Ql3;>t@TWz8@W>qZV3(4n07|S`Q8X1gqhvV|iDfLM6xgLSN~~;YHUhhpB0#5!53)&#scHmZpu+LOjzo&W$s~)VPVv4CW2tb)slu59BXMRsEu}GzSlV4nJ+C$Bq?`s6h=IB_ajoxGwv>VjSeR?9|-2Uf!1 z#46VYb-*XKQa6?0rKp20=ZRi>Y1Ot2Z>hIN&fAN~O0s)suG);}CvjY9n`dp6_tpW+ z+fWrez=|69tcN_VX=aZO|F{uXcUBQoO+Sddq$i51nryLIIu9-d$D&oAfz84}gq?%j zNLX&c3zhXLS5(zI`qhkmw^?Yojmd|n8nwo-J|l~&dLNv; z&g3K0je285AE8B6y$?v9spR0!M<0EZDydGkN2=w6pWzE)edC}n=X$>ps$Jwb$n7hL zWII9&ir+HQYR2c`bACa!4Ba>4W@&z^QG)VuI9z4#2obWcv?|&!m3y`SFpeONch(}_ zJpH5QB;{f=IS-yWVDvLSsWnjM2F^;WQO41Yk_c+IDo9WTmPcL%Ri>{^HmZ%9RRL5X zgc!06NI%T<^{K{iqi%J813WiLKf?5*(~XhFs8s?E4csVwrkjILLoHA>u3jn!e-9M_ z2QFJZ`s(8=d42pA)cx{}+QB>io!S9S9~)wQ%ZHI=W{xP|%Dt!>qI`??qUwn9t=C1J zhrQy`=02!3K1wqmYc)n2W5qT%puvqZEjsM+Mx)r^2Be)}+U69-18<6%iragTc z{ru_0rq-L*)o1zO`Nekjnt|=?VOOt7a0{NfV4qoI%huJOgL}eDg{`oq1y1h?WtfNuS;17Cgw$ z*-f>=DWBccWH{xso0}ZD>2TU- zH@yYh2r_nbPFuw}4T*EQAjD1F(`42J_riUud#aXqjwkdS|B2lKj4s&ur>$l(zlUce zCxUI3C5%*tP#qF%lqKANPvzO<)jba)sq%uKYF6jZBxyDMc`)C0a}|&88G)ywQZi`}HxrkVDTBB>x0Fm9v=xv%55X5_`OO*hb5~%kIg)Go_c$u2j;}WU8tx-i z*==<0Xi4M#fpPQGm8Z~Rg5Wy`tGXd-@lg65M#U4@UX*?cLEL_wH^4X*h?r5V$jL4y zsR@C`Ac#z61R5vAni$o!IayLc%#c#C9t099)`LJo#d>g5tOdk`O2w&-Ktjb@5J;$4 z3yz9)FpB9iw^_-u3IU;E4G<6#R)CP$W+Z+8vjJV~f*$pK$uT}i`MP>Jea3PE@pzXB z<2dN`L!uVZ&SvT=yG7o^MbY*^yy3lt^b6r7Gf8zRs zC~$fTqyMF+v4TxOPk-k0R1Rhlho!m(Us(zcc59K|hm)nGyi}HN={$neXyc`9Uk$%C z0WN=$+vO?o`Q`?EzLE2Z<#|>Jc_7BogQNJAPiL_11_c zG)ZK!VHBUNZHE!CG`!KI6u09NAZdbdAWQZn6Q%@PD$7UxXiF^HXgtdDvD}zF1;N`K zax@X-XtGTf5-H;+bZrCr8OVcW79NbB1+SCn`oC|WqrZNPeEwkrKHu{B?1Mbq@0ht@ zGlCn__n_BVJcL)x7l-5WVm(e4M=DE|>QYq=)P1liqW{+YbQW?rs7OQJbPv$;@LAZ5<`@w@=@PxHmGl^M(R64ePf;>KhJy^ zPxE1pWc?9|_w_4V1 z3rJUXbh><4LX0dPGLJwP533cobcnTFeSC{Ku%naJLru*>M_4ugEJ~vL6p(=f*|;$& zbs#$oisU-jzIowyR7-qb!Gm?Kfh|S3j>0vLgSv*Hrb2lkuG=;g6&A|tNL=V*v_yq=reeU|YYNT(gMrGTupgotarPiFR;QzhH!Jkh+$XJ@CzNZ^) z#Q%RjZvOiC0NHQ^3I5bmzx*dM{-xkwQLa}(*ILbZVx=BP28;E`ls1BZC=JVx30zMZ zjwq?X36&Fs@cpoEvs%Wb=524mv$?9Y^+u^<`z`Pct%}EJod%x|iKv)KV#Y`ep0kN= z{4}<87qd`hl#r1$qDBo1U?jsMB;7^iF|r-dUK-n^+bA2OG8xg9sGHt>QUNyHs2%Qs z54u)#gKvwWwegBC*{^+3AYQw8iuWafck60vuoy?qrIL^f^{QOB z7zs96m#{!KK+xCaDZqywO#Qh^BYae?&})xx2t}>H$H7*}z8iYw^LW0%qV4~8kzgVy zrA)|riL?D{8XpUTf&Qo>B>j0NLK5`&BRc6)BqLAwBRWs9= z@it}8V9T82zj5#uKghggx>}dqzf=l2nml?i{a2PIeH2$K$mJB^=L-TTLzZR4@r$G= zqgE7oj`V641V5C;=Ph3}P2Ww1MXqt4Yov*a@ufjXuWVz;%gPo@(Z*F8wqdMCNt{VNhEbr&C3~oJPEFRadComw7-^=sp?IS)aQ3GhQy`XX~k-dm6=Mph&=Mu4z2-^|p*$uMSqztlmr3|tcrVO&TrVMhgPC3xt zpK_pW1ahFgN##I$oyvjsPL%`g#VP~c8AD0%Bc_XJ$4GdhbpY;2&pC=_CY(y-d}k0a*_Zv&j_X#(QapWoA`KIU35UT`}cY zD2sPRYl~O$`h^kN(D~MW9 z?J9^0P{k?;-K$O&gxXb|3PR(mNCly6RiT2^vue*^s8|(eFtn>WGZ>2fV=1q}(5XyF z<(TmM_{N_p$>O0&)sMoteeQO8k+Z6vf`&ZjnP%K?mN7qe@0p~7ojE$#nWBT889LaR zpo5+HIXE-D4B^Z!LpYPm5YF5(gfq1a;mj;UI1|ed&b%^&GcAWuv*NiypM-7krwulp zfL_#oB#2|UXgn@V%W+|vjSJIeT$l#q!n76_rm46v&BTRiA}&nxaABH;3)3uInBzeg zra5R>&b7wZ%H)SLQRsbiTU#gJ2KemzkpPiw9=g}fkNgRZWO>zz`;mtaw_tqigcr)A9Do_hsiSV_9c&yU%M7*?6?9`s|j zB8C-c8_M&1PQ*C#zIfL60T`%!am+uXjmW}TGI*XQW6b;$XnG#oA0n6Ax&PC>h41b% z;FkHBd&`~GzUonh&BL15U z|G9?$H-`U0!+*{2UuyVo82$z>$fA%3UaTPdb!LPx*{?GrgvoxL86iye>&ysYvR`LL z2$TIfGeVf`*O?LXxFDQ;?gxTkW_&6=hfZ@Rj>H;|HO#Toxk$5x^Xv4Ph`#YD05Pe( zYhf|Ev5V8@!t_}{zhe7@h1w3&!RJ0W?z;fVUk&=zd89*nQBo4WP85_xqMM{7YQa+R z>qIBXXz6vLkfbHL;2`t-Gr}m0x|3(7J1J&x{*#I@_sqRkgrh~A0T))9#M}2bj^gc} zU&h4_8jELU_e9h4Lz7xr$VV$m>j?QvJ!rOJDL!+tt0IM}W>soe#MLqH^NQu0*78MG zzL{AqN2ul85*fQBOr(00lUGccAHNVhucOW%I*)~!MPbtS;=&KWhqYw+>CnJ%d2(m1 zJbU6%Y#kV$pD`Bmt?(hNruj4kr7ogi3VfHOE@8RY?vXwlH++`5mEMOy8TAzfSVFS; zrVgX!|12qI#&->`e1vNJMZh>@d-;Cc&ES_GU|97i>CNCZtOl=X)ZjJjDLR=MKW7Jc z3Ljdh+GsK}(K+Yzm48CE=`SIRkcih=>)^ciD#-d8mPeXKEt%X|Nkk)i_pHp01vmwY znH+loM(kRBvws_5XPKOcsZB`Y(q9JiIc0L}e5gxDwj6JT!RwF*?KirW%HM&5JR+?I zO`k~CdoNaYiL}eTPuJWMX_*zjd0~!XkWfPw7!nW zxp3tJMMMyMCX5arL0tMYNCD?~JHnCy!bcezSy;^CgP7+n%Uo~eUm)pLH>C;F{m4otc+5=9g)zCXWQx zupZ8%;gV4C+(>dk`Yz4_lUy)A`5cyxmMntb$x*x_s85b+&~_TIaPH|qKhImI2ADDc z=B+afn6d%pty3S<^KM-F5x{=>CKiV?67%gjLi!?g_|)GIQ~GS|;^}lWmT>I?(Y6`)>bR z1f$3kxZrI3&(C{hnez(a!ej}@DAlj$zWt9(DA2QQb(CKrk1^oR!2i?mKfg=)>IqQB zSgkArG#fLsf%(M2d%!D1S)@8WvAv*Q4PIdiRbhDMm>WS&vD>6h@mQ9Y>QK}%P`RqN ziTMFV9`JSvvb>k8B-w*xIZ227?!`I7@Ck3h zRs%FU;aRitV-Hi19?^)iBb+eihi_LrX@A^k&!!*w2?gM1;NX8!0H%4XrD6D|EKJ*c z8S>&U7ST*V3LmL%3V0R+c-{(lst0)9(4VtZfW(r5Z;b`HLinA8Tp>B6^f=91Nmm!u zL2{gTiHhecNvbW-e^{sGUBt&tb-RFk#z z0-l<(=8mxis}>M%GIn~WFLyx?o{bkw+$9=NEuJ}f-pLVAtx17Z4ylk?)3&(am z7ZdHdftTIc1m%jY7V;odukB$R^&oM)w(EF>9d~SJ(E#_eXh=4+2m?G{#uqin5V81N z21AI&w-)$(6gYh7f+0R`R^|v{l}kJwi_ydimjF}(UY5+8QFBziNQ1j-jvj1OJB{H^ z7w{w2vCNQ^)Nbuz1XxPDwd)8_g?4L?AV5`8gBGL;Em(yP5p+tlAhl>gB&Z_j z^k_j~nJ@D}uKC*9&;dK@0Q1zOnWh@kH zYAOp2)8Zu(r`bF$7zjs1QnzEOTM*TlmQqaM(gh*?x8T_&P^5V zfpw4@cQ1k3IL+Uy2egXJ#v8VKA0HPzh>ySFb6pr?#In!i5bGf?rwxs4$4TBy@l1&> za3q?D<=9wlU&%x)tFGNL0uN#U(QQ`{`n-gy2z^09UfU%F*Gz?i3vWun#n5h>6kPc% zv|&@~W-1hBBJy=g69kSrx&ytcqyR8+e-VXhapHQB{yeRUtH{+dA|D=9XHDJU535q zyH`UtxEg!D`wDoTE!o6B7uX(!`onfZ`D1rO;b|}BH^{zk!e{G0bh5k-vtKMc_p=-i zQ%{8m%l9x-pLkF{T2A*6s!&FUER@e7UD+IL z<+@Fs)rl4c@9sOh)PX$`3hoZq*zLi}c}u^GWsB`NMS)3x<4u;`g5t9V8uT$<{AUdU zn>opMUD4QBqZtRkAV~-D`&%X;HsgM_^44M`IrwU2|fb#@L_i-NJPg7WTbgcf2 zj#aL7M)3gCCw}^Jmflj99B+PWQMekvl5)ZVj|$Csg_~P#ye@Gkd+5{HL*v|Ce3C804mgqZH@{U9>_Y{!|k2o}^8`Jlrq}@X@M|maU;>X4N zNDY-TCqgHS*q*`C%6aW}XFVX7694nqEkZ6>o}tcgBM;m} z>AHwgop3d!YcoBP79gR$Kv48XQ2T0Euw` z8Lp@vS;x2%cd4KBXJHMd{Qb`{)zlm}OtE}^0DX=C$rFiLT0m-PCsY)@Zd&O|sMlG!W+*1Lev*0=~N;mz^7YHwwOazSuCV9P@m!u~kudzBuc*H(#9fyK%lh z@ACbYE2J8bE1zoF6-~A5O6AN)?6aPghx^X%5w@HIz8Cm6WNp8uYO|fi7z|T1Oqf|T zPM298y!|1Hi zSzSXl_bEr}hPJs(-9&h$sExRfATH!N`P;njtXLNv?Lg{pG16*v!AgLBq0Aq z6ZWf*O;#srzpM`^!*4s=5Dl1v(8_YXjaHfKZM5RLTy$eQT0lAZ!=RrkM90e;R%Aqp z0I5q^RHGgN^CmEr2$;7nzs(i}ZwDWFZX-NS!DZPKi(2B|jVR~4B@XN^CyVt6FO-Nt z(!vOdJkq!bi8Nw8^K~3)f+yFZe48Kw%X`qv9dZintLyix{w^<2rSAe3W$Cet4`^D> zC;tj%q^}nTh-W{Vr|tfIAJQQr2oAimgpKtgxVa`w$OsZGC9nnsG(n=JDCVMoCP=jC z7iiV96lebBecZLp^>No0*T-GkTOW6AZKd=$m4H&PynMFeY?*faYpM$ID?fuct#1k^ zRcD(i@EZ5I*Q)F~+Q2)61M4`!TZPsl@V*x{1c({|#2X+g0uXQWTm0JUsc})ftM2~x z@g+oGe!MTuU97 zZNH848zyMEY_}gk4P6VHmG?Hi_qqAP1Wcpun&XIbl+D%)KdjYGAkl1*$ zQo_Ps2^}>bJ||rq(x;wHAYvJd$JFZBxY`Pc3w|Uq&m&mnz_d2}qTH?>=({(3H%HfO z{sLlOleJmT-_|SIXZ+)%w;$Ypnp6cI!N-;KSLpt`wfPrn0`o&7PXQzRDC1Vb>yF~q?OA~?aA-Nlf+ zRrhfo6Z2^#OMe3wo=uhkl3V%*jQbT{7$L46r_2b0GWGOv3|w;>j9PPG69!Ytz}V&Q zia7m3vv(sq>qqrHS1&Fb+xLw%vN5RFC&+swZrtwSB1r**9d>uca}-meRx-`Z%nliBI%#SV&{;0~QI{ZeHkQ=*dr7@)IbVTWgJEfBu6|>RjKqq@_r1 zea{ug!LBF{cExb8tq0;;(qtpcf2t6-QJji!VJg6_5OR(j(pSjO2KDN>bb;xRE)c!M z2Kef|3Q-4atgjxd5OszP`_+s2QL@FkXWfx?evB7?-BDmONyr*!XCyo%F|%;Yy2tr* zDAnx`;-ar?ieu}!tR92rkA5C$5P`4$`In;yHI{32bKKMQ5CT{M`U+w05jkvoL^#%} zfpT2@A6n14M#x?h3%fL-OLN3aIo_5z18_deE0V8@&1Zf7pBX_$Z3yfwyO7 z=drs9u9;a`hE%o; zzl?XHFE71RI@mG+(y*W;O2QhNLkezNHiIPWry1~Fa3vg6*gPROPs+_xu&LY!rrF|6 zP@>PUL2qD#MR4L!*kT>599p>wGUD2cE_#udxb`BmYqV*9CNLGC(WZS0XN7Pq7T+G$ zC1r^kZDgzmo^c2s1udS&?QZ=T4&(2Eej(%ILr8(~u^l(&q>pd|<6{SGX?&oXjyvsu zUobwh2Z#*rP27%;dIu6zk@?OK5!R~zX9nuK0Ks{m1S3t382?d z?~aeLG(NBua(v((jt?wL7Ea?s)`gPBhb$T;jSs9t5294#1InR4S;i=-9R(u<#swOV zY6)XR`Z$Wl2o^R<4ic~Pyrg1Lt})>)u?zHBUGYB1viY5CQuEI5jFDF{ ztdN7JiJ@SJgTQQE8$_UV9_mpWcF3}VUg$Y)U@l!(H~xv%!&@vqfUAA%1{*DxscOYFgE&V3+JE5LFUCLo|iWxQkF} zKS#8b_6x)z3jd9$E92dWn!-JZO_cGMh=$UBg?Rk9>&9Ndm@4dvI_lYEZ17qTK5Ohg zXmM~P><6C*;kT`^$K90CFF;C|Gd3|Ap7xF({UQ(*@~M&esepr~ML^@lGST-t0aXjF zqi$681fxm&peE2GuRDR)hcI5}WI_oI*9>b+F(%|7VL3D5+b29rz?Zb}eby3Za~}EK zpg$au(C-F~%b18|z&p^PT2%-zIim^s|*X z9S0|raSPlRL%Cmq+;CTi+Apb0MiYE5z-euUN}BL8Eo zy%sVL&c!W3pA6@QKDG;tpx_43M2Tb*Mrjb|0o|JPHI;HL#O;5N#gR$JkqlvKAthd; zrnu$6HC8nga{7|+`U#9)1|!`Vdn42uGT>iHq44WGse+v$LQ}29sM>~!m7T}zukVD z>w=Ml=M6loItc3VSqbQo^#{Snv-ShAT2Lg?% z;pjd9y@-hhNeHi?!XQ~vIT)&)JODZ_Tg-*I8|~l&5I6WF1X=>(Mw+7Ejmv`&Nke%< z|DZhhCKFnoG{y49y8iJoH-?3l0&xiT3m=4$bxDJheQ^sQt45`q&^EUuZd*fn%9r8X ztl_8eWw`5$G(cajf*2Ea+(?;qWN1#TkaV0)D)AcKqI(b_yJ!M$oJ1SANdh+#;Kt@A z9#7*0Sw5Iy$4g+dMhT(ywh*i#GJbAJ>Z&Vtv8C zS6}wc?wF^JZ9H!A-iq5AJAUGLr8OeF_W;jaI(?1cMbLBEaD7KRxUlmjk0;pz9!_{` zHx07Te&jKPIy`jLCKn1gZ znUlI%mgKdCo#7ydOm-E!fnENllvA!$pE;)zsFENFpspapJ2j+>0d zxpl&6aVrl$n9EO7U%Nl84=w&`eUsh#@Lae6+NR_612seq2`o#N2rm)lwnJwMI04+j z5ZY*^!h8^9#|_SfC$;tVhPq7wYgQPai^R*lOYzDIzQDtU9nk0onl;LpH45H3f=OfV zP}g7ZU1Y3b-GkE?&0%mU+q%fsorV-UI1VZcO$ps6*-f`MKwWANyJZy=@;ODj2&lGUv zTUGzU^NJ2WuZWR9cs3D61Mb0dcW~K&F;Up#y9(g>I=f+r!1IOhSQNZzRt|iKXTzn1 z99^(q!pSgTz|cd6jjkb2F=p<72J&|dQzXHhb`y@*Mq|d)Xv}zKje@U*Cy$x`Vf$r! zsNwK)VbEsyMHpypH2x5c+t6tGC75CGt1mQ2@d+~=zI5Wj`x6x7$pddjC{YPG)xc|i z6_Ww{kYdB7P{_k)?H-1AcG+S+9CQ3r^A>#Jb!S=V2L$*qs)sEf9Qo7de0bmxvjslU zq%7XVM0s4{h7z{GC!Lf9eB*4efG>Ph%ZF%Dc^nSoG4{~2 z^7x(XKRL!QFU0fNV0f&1u)ZJ_4!@OV;X1_^I4_w3@8`k#@m;)Vgg-2c{VablTQ#y# zM@_<~)*B4p2yJVl{+fi(r8F3xzS}0@Gb{WqEVusCcj53!_*4tn)8q57K^z8KS)Ig& zL81CNue*%DanR#?c*4Wud-zow#_S({pH<&=Px1Yd)@~Qe zLfYXvF7ET%Z9BR#PgE}FI{HY4=?mf#8vOhiRE+0M2VnS^=I8s`1wv!@0;%!ilayCa}Y_*X}oWU!R?v}n+Ux9T8%51@uVqU3?b5mse@hL99A z>Z&|4tqQ+6z&$NwXF?jpv<&%f7el_!#h{1Mah;RX`RzyY#Yfp$9{3pQpjPCbkRKHPHe#SklNw z1>Fp}$cBp<$)!juT<5gKZBQTn;aUmW!Z#7zNZhs-StqI0~)P|u7|TlepY(K0`L{)3->ohU|kcv+rfWB>O%|g@872)==Lz}_D%`Lgs3ei0Y?f^9u+S3<>TtggxPE{a`0I-NozEli zv$>%kWf{1RE1g0)6rLKyX3MIF!ViVXRbBY4mXMWQtfv>3#lsB-JvvG2x>yjO6Yvhb z#wT*v$py-_-n{?Hx50Fcp8wzbl>M|j$54A3&kKzvO?vW9h*uhSz=?Ch2@@tfU&3XPdm-52AD^O)&QSO=NFNuVYdCare<l%=KEKUAV|(Cx5B)A$$T}@} z|DUfpqx-myj9Xeq#vQqiOnbPFj5|1wVxOZeZpjvRq%G~CE$*N#9s{(+E!pCZw52_? z#T|K^(l5YPb#o7j1;;uOj_tDT%V?WcV(CWR)%paSB7!V zT^W{I$X5XC(*&?Gj9a-fjC+mOr?L5bLV*`ZpPpDwxR`YX{_;Qu$;`%0{uV>-0}!J z#b?G=KBZ_K{gnRTD)}G#gBE}64_f>+f3~^)VErFU^>P>8zx%Plb6Z!Nc zEaRYS7&w9Fc>#uks=5!QV~9$0 z%LCD_M%s~d08x#71P+py!|9;W1M3d889zHu@8?G$eolm{b#)EJC%UX$9x3;0oIENr zT7iC(&ls&hfRF@kc<3n=HUU)B66vv0q5Gi1jao-@$3JxC#|_6;#xW*@ZLqfJb>Y%-lr%BB|d0M0S_EG@R%vS zwojf&sKM|Djy9Q(U#ciao_zNlo6_6nxIlX2oEn`nyn->6Mwjw%KFKxpkTLpM!x*&$ zyp>5z!t?0=g}BN8pua;pIy#K{I69nqH=5q}R}$Scq)VeCurs40(O_tF6uz@BI$G&L z6B8R9$a@lI7Efe=hOW+Ank*v2Ak-q$>0m{MV=RUf=&&{kNx*p}vgrvqB0>x(M`TC> z<%l{VM|6k*<%kJA!jXZvlITEW00J1@`_an<@%u0YC+Lp{qY7Q%2y^Vk=IQ}E;-^4_B@_mOaT>JOgo})q1oonqd>iyHOaeF%)u|1y^69xvR|)q}d{7-D(2PI1TIJ`ecP zM!rVU9nhyb0bIjB9r>ZN@hSRb@Bgw-sPK?6e8PI)Us?;rnAHjS{?gj!pRLdIleW>UGI?B(<+wc#=V3Lalz-P zj9E6sxYA?Am}U(R{NU-;5aYrYF~!TNuu;Sdug7gs2ICXUlQAzG#-TB<#^s;#m6bH# zgvP<(!ENlq)5O6r&Or5zZCo~ey8TVx!CUs-ffwT+#?JMeQ0z%>pCotPxR~pz%N!?z z=UA~PIZlQ-WSmSktRZHG&nXu3`RxuRYDZ{{tOGtQj%CPGxseJZYc$+QhN@2SdsujE zX3{(p5?3SUVMX69r?5YDq)AqBH3vMn)eAy?#iJ_@5d26ujrJ;hX`!1&(KHCJ;%QLj z4^dDK2(ytQOe#3^Mukd6I4H7jfH+$`?7#-^0)P$9)Ud&O1K`}kXLCvKk$O|=;n_=R z(C}_dvf_S}w%l_v2WMz_H>PV(@jI&9BP~t0Zd?~Qhx_WJIG*}Vj(%`{g~ah>W8jv4 z*&KNHrECzq`;wbP$Dlu#D}RBWe}`WF#617dJY05DPLgnSMW0>#gYfdZwHyp|$2`C5 z@~^!k5?zEqA36vdtOPdXoQ&1Iq*{dMzb?>MH|_^9HT*tH&-!EB57Om3B4wfSDB*Jh zvRLl*lgowoGEz_RPc)D-f2HAWL=fJ~_#fqmAw}Oc2ErEF0?&n5Fmt-`!O-_IV(}0I zq*^k_KOj1&8PsP$bbKwu^S@w2lHl#Q{%koPiTDHJQj0;(}qhz&!FNEa2c{KKbhvJTBz#R`9SesFcuqltS-afsYO>3r+{z;KwPJ28bI( z^aT(%h}aN7+{hxqxzqXvVUh;l0I(408vqs|eH$8b|J3Py!;kC`-w;E5Lk#gv774y# z?0`B8uIzXw|20H-;}l+Km{}Zp4swyRJ2~8)BQ(ZrD;QU`y>DewudUHHgf>6&aWk zk|kR_0x?hQqmi;`*kH-9L93CC%Y6VclPwpEu}`w*LZvzOr6V4bT}d%e%mYzN+{nr} zYS}13)(>Xrumm=1lpy^BGptwwn>9+1{(~7dLjs#MN@(0ZH&zNmtx>Er7G@4Saq*g~ z7TRUud_v8^XGgFV94p0LjFsY+W2KZNn}e}ZYzxOqaTjByxaC+WCCNr%tQ1?su~OW{ zSSfBfR!T{-Y2jWEH8j`oVqg`U7!E(ff!lVNBzMCxu<8wIGOn*Sh4wVG7gh}8Wn)oy zextU^W??)N-IRV~JQMxki2z=Pigof#5FQ%c^gr(Oz=61R;{oC=@|4+0hUCl$b*aPkPzkL1&8;CJe+)~UGcVx_z_8?{| zj}{u?!6GBvkw&yfMtHQ)2)AT}JJN{u$OsP`8sV0Va7P-^9vFp8RCIi0oYp5k4a6pK6B?T&EesEg)6)J>94iofC4kr@Ze?r|_uSZ| z)PiY&YYMSROq8)n+-vLwb`_u4;002s7o=q`Xn!bsK>%LhR(gSZt`}0vUJ!s6xRqYu zUSlutSb!I}0WWY9>IG@p3)*+RAOJ6LE4{!y*9)m-F9^U3+)6KSudx?+u)z!5fETz4 z^@6nQ1?{_D5P%oBm0sYU>xI;^7X;u1ZlxEv2eGo#j3-#Wzz=);PN?qD2%XO`&Wpzs zexe0#L*}`Yo=M2& zY2oxfV=VZOeMXBv_8Bey*k`o(t3KzrKI1hNK3{bUoVWi)ToON+=u=9?B~^+YYzdV? z{KLcr*BV+59fcfI}pu}OMt&W%mNE0W;A1ZdD<=n)4W z%`_aFB&Ng4u}Mmx!^N@5h8!|B*^q-{lMOjIHrbFv#wHtbaBQ+62gD|oSB(#LXrQtS z1}ZU5xffc4f9evP!)VxmhBzg9@5U+Ji&A_(4KI*zoT_l8%;rXGWHuSDbhBa5vLV}> zNbcpa8?}_#WYp5lhOx_rY#h9lwY|$KnN0>S-E0`bY;;+5it*mQVZ8sJ#4zz#s2C;{ z9uogK{W{5iwswWFq0^W7pRGCl)isaD`I{Dnjqq5|4ju;D!O;hSB)Qh~ch;qp?O#~S zp}0~XID#;NQCtc4L*hy}I^nxBdZ*$_*ScT6d0|Sf=+MGFTqBwE{>g?I(+Tf9#sVAS zG+1s!j0v00#EYLyGO%*;JCAXwgvOg1*ENw&t!VZozi8VfZn^ZFRxdaZ@SIlTDrA$~c$3>4m))kg>^8$?j!(fmkFjSs zK7}3P#;33&+I@LRm@tDs<5&E7vVjjkDK6}J-(p6DMnq(EniUjX&jRGMbjipa_5TUO&rZcVz zejEZX88}?!?m8!NS;K`(Mc=8Xd_oQv>IM+g)6vODUd zVg84ApPehuQH;6Z`rECz#!`7cB*Nn1=nF`R=N`NwO;mv{O3>S^Vq;^2{ovJ@bVh$I z%Y>*|5>%oaqv0dMH>o-9>-q%TR>JJ>Yk4eK1X(7vKtK zF2;K;(Jg4iIiL)*PZ--G4&IUnpMk!HcTZNrZ_4{_h6}I$SO9F#m0LHj?145<8>0t+ z6Z!;fP@7%Q$5-e<_*nGm$yPG_NLmm+>);h?+d+a3-oN<~?7@q`jNlHL1btwOYG~7B z>;ohCG1;S4r@J9lpOAtD$LeEW1s~yvZtM|Txf8ULFx?pa3G4-l=&xWuyT2ZUOB0_y z_BeLf)igff-LRBqFym)=D<~+9j%f#Q!Dqqhaxe!nj&p=agkN38RL2hL5XtjdcKgqu zYoH%ao$rjlmG7)m)`zKoTwg=J(E9#7U&m9{hpB&DUqimo`u;rM*{7@zQ~$WWhJ2y* z{dvB;Q`U#6e_UTfzR>#qDBo=~UOF|d4<-g2FPIAT#hq%roS2X5`wRKx`0U)cJ|3T# z`p4~S$QRnaKhM|Yl=WfiAJ^BAFSNct&zFD7`Y`p6>ubmtTHmSi;rdi>IDhdEX8(OS zKO`p`LL`^K`Ca)naPS*S+zb}UC@69CeoTxDeoHz%*_|wLE|>um;di8-)E-=gw@MxW znsg@a8^JL&@63X|gJ@#}$KnheycuPz%wPnsL!+xe`90c%7C?sCbZrV>a_|($371=N zzcX0lv)B`GsA4*9L({PfFdes{>3Hg5I&MSLajL^~+=iy()Pm`_4Nb>Gis`rwO~;{y z>9`F|$5R8-aSQ1`kpK934(}-zx5GJQ1b>7y_;HrtOR$B{{6nybh9&NnNx9LHp2RcG z#@#L!nCCqKBGQu_1)DA-<$f~m_mlhaa6r50u%9;tgcWyH`#AV0Z-+JC(g{kXBa>GS zIwSZKFnq3DK%biOz2|`VI`pBP`e5$(tJ>%46EJg*pR?mJgCiJHV8fBk!+Y7S*sBV> zu>FI46L7$EhL1D2l*2)zPry+V{26vTy@RRJ(}sdW$41^tuz*U=h+wmE;8EUv4cV?o z#=9rMsC_&e-2jP39KCQk_zTpNZ8g8D{YX~cc%srshS!OTQ0wG_$Kh3mm-wvYF)&!K zI>T!v7vN6&l*+?UT$t_z$3rR3=p#TmVTOF8DAfex`zY3k9)ak2LI0i_l#YL4@c)K( zXXKu7R_@vD&c+lI-~TF>z(s5tEE2}A5n^Q#>|Zc$?5Jz6tVD}iLlY74kapn(qCOG! zAuX-%h36E)b~mu6HE_?0(U+ld$RCUg-;m>LT6$YR;!&+VK2U>R+ywtGg#U1|2sk}O zrB{e_U>lSz;Qx8B56J@5B9gZ-W{G{U#e03q;QtEvkL7vbe+v9>62f>-P)qn92mir! z_;Y&z?{jSdvC%msA0)Yg~{E+18Fw`c7qwGtvm}Esb+Rq}nl~TR{ z=@W;;MH8@Zg7yQN;Qob8#(?~_iQUu^Gn-<)dzzv)HL6vVB}$^OoTo^B6ou)nqfuHh zsEv%lGVR!uSf99nbT0y}M(*kCI$R@=KCu7hnnJ7F<*SwUA8j zfho~FQ5KUtyRZd}qqBNvfV`08E|T$mGNAm9eL6#WA?*9ahVYcwCgNJyZzATBb}?w9 z#A=e8N&ZeUrZ1-N33P^BmHjZ+@%|Z5WB+sUsFk0K-cBW1O(`2m?mQQd+CfUUi_j*S zWG9lvB(EbmyXaz=XW{*=C}^B}QzFC!5e{b&j(ViaOe9BiCCagoeDH>-$?($n>w#Lq z%rKU8y}YOk6Za7<^&vGC??O2dq8_LfeDCvXNd5fbB3Z=H^F$G%O;|Xb#WA9phMxtV za3My)nU_LT&6Gj(6jLiIWkWcY886yEt_bmJ1eV!S^djA*k*G@*{fNFG$`AvH;-bRg zmv6JgAfk)_TDBE;Ym=druLFkz>){6{5jF9{R4hu5=%KN z38|QAGSP6Rcal*z4X6q%XQcd`*hjg&prT37x#)--3z*+)SnYgphP_! zs5%wr=lfvYz?&k(np7Mi_luT5aQxDcmWnfo-XmHDzdV4tkBJ@^-Ed+Tdw^PrCq*AU z8p@mo9{{F!2HvTTmdnzylxKl(OzZ+`B{qujL`Ru!CCgwYTD~S`>RzzCuJy#$t;BZG z%4qQOGf`k*zr4_9Vr#GVrRZUx<-K_mTkjGRv>qXrw`hIg0yRQ>n}_w?ru8#?aNd@~ z#UIjzhEIzWfiCFhY;7=5gviWCTEf(hXe|()0mVRG?IotmfkufO;)IRj-K@ zF}P|A$*m-Jko=tFw;(m~6G%&3YbI%yxPfFB3-^0knBE@-9enPQEGBt!%1U1fToruk zE3#8W_pmK+VNn!T2Xb)ORy$H$6!rn^zY(7AM2h|4y&X-Q+2jI{vzv?nxw6S6AYW;M z_8&q@ir5y>*_$Fhjd%)5+YeF`qatsBgEKmEE9{RaDN_#8e*38Vz`jcq<}C!Ni2+gn zgp^C8szF{!DV0%6VSf@xO`yHB(L!uo?b+}0IoR?%b9bEMw$z>#0 zk$i#V>m;|4{D!379PN`xo=x%slA}r9MRFO*S4nh~^Eii9;k^@OzLvjYmWh84! zeopdtl8G%bS02d=Nsc9X56P7z-yr!VNh2BUlSy_ZIgI3uBf1Ql- zdy>DB^rc`*49PT-ok$jwyqM%wBqxB36!TM_vO9`RDIeHy^%rr816P8nD4&8cjQdZ) zs92YZV`B@+k4PRQX{BL$bCT^z_5i7gGVQX6j$%++is&eYk-QwFCEiH;KEe`jkqq7c z@H8o(L;9KGK-!_mGli3mGKFMb`eE4rNBXfyOUzA=gX_LU=~&mw^sUgA_x-6+9mU#o zlrNF2CHW@FI*{neR%qQ@BtIniImp3PMh4D2ktAbCCXh@A*-(CYbVt!Pvpm`od70R* ze3Atu3rY4PSwwOm$zqZvBu9`eC0RzYoMZ*bF(k)<^oV;}&xwQgWVc=b^3m2?ZI4(@ z@^wmipX4r(7Fk+k30JjXW0561i%eRyv;`8Js$x4!UkbH#XMw0K7+(+^_$*5c`Gmd1C zWFE<0B!`o{mSh#l`6Qnt`5MWcB!40qdnT542Fbo8OG(~DaxTdgBsY=#jO1aGk?k;V z7RdsV7myrD@@A5=NG>7yJjpF2KP7pTWNdpZCzoVDl9!RZp5$DT3rPNxWHrf0Nxn?- zeUf`g9w!;!0n2Pp@_dqGNX{a;oaCz{KO^}Q$(XY+S38ouNe&}9n&cFc|021bw>d-au+PK70Gra z^GOaMSxRy=$y-R?L2@q1r6kvOITPxwCHXGNPe|_Tg8uwK@;FI{QARj-)dUVFmh~AxXzldbtd`v0I?~vero?f2cDPeHc)g-ScSw(Uh$@wH7 z1PQZiK3-=&kstbrus^Y*s7puLHgkU>e!k%6!doOiB>6eXV=?kgb$c6>3gl>41n@lo;WDZEwo)6m3z%o+o=~mSuR`|P51=)mT49OIdnIzkg z%p+My@&b~Vkh~V823MGPy_!-mwFUM@T-4yI7kjoz8C>-a$uCGABI)gg=}9Epk?cuw z5Xs9(jwN{q$@@q?L2?txk4Sz^@+isZLM$_xWE+qTpR-e8e{DL-mq^xu4DH(n%Onjg zQNBd7mSi2sPinu# zNq$HvUy=L?q$ZB{%@1nA*AMH8A=$iNKI~_c>_oC3$sr`K?AHVAZ>Rm)Bp(7fFd4sL zPmBLe^n;OBqi7(!|8Jut(M~Ic?{*RJwE--}*+l&$IfYso=t`K1wQ`_xrmH|_iSbM~ zfX))rnP!8|7IjREKxYelEfdt>EC-zvzgWd#f#;VoLYSutc$N@dY@=B)8|CnnSLbN%j7jyLcU{60iYxilR;iP zX+SMRkf|+DvdCxZ29zp_na&4F7Zprb8uy7zF@|XzP?o4-nrb`*ztOXhX%0}fSjAKg zlp{7Xtpqwl>>~P7d((J9Oj`uGUq|R5S!u_ZBL;R4Wim6qRc|#44uE=4h>_Sf}VFt(VxW=r*lT z)DtZbUzrbRy+sj*dSIM=WiHkFij7RddQ$5r210ZOb;4S&^%n=3{8p`Yu1L<2I=}Uv zHb9g~a=gY4ZJ-##6aX3|s)%Io7K<%JvUiI`unm@ibO7QyV~D=guy+TGbwsjvOT=#0 z?J&O5N<;(%k%ibKu&;-T0wV0|Bib-AP!jd-2vM%6hjx(|r|4Ym5>cgSh<2%%sYuf= z6AKkxs*My&6qRdNh*eD3*H?;liXvea*{tX$?P^i4=r*lF>>|RxZlhl#O50)^kho*IyzOv>j3fNmBsM6%~6 ziV;Mz=O>D_iVnb?-^Yk#&)*{YwZl?m&sT|ZqA#@_#+`bVn9Vxu`N?7<(E@R+wMxHD z9P1#xzTeuc-ysUllC;YDRG%R#m|nBK)$bPTm_D(N>9Yka3&7t3Vc9-op6I~T%#Jng z6*UxTTp+UT6qpUtDO#~W^s-wU_lshtA$CXOpJFysg?*0kpxDoJyFJc$Sd4%*RIK44 zdy4Uhs8=-CSSsSXO5JMvd1E;|>g3Y9#uH*X)9dyx#?vCKm(;y(dpysIflS-&XwO=) zTT!y-MG-8Nmiz6to|i-!ljan9Hi~LR7kOS0xxJ-jE9WN9Yhnyj59fZ*8)A1KsVjCK z^}Hp5eI;GxJmYy=Y+;(ss3NH3DQB=6bgzr{ohv_gNL;q7Ja5gUo{ z{3{n z17d_EvCMl^d@t5AJ>i{ZelO~o)_CUtc?My=1!9@L0H{FGV)Kv~$Fu@;KZ{k07Mn-J zZl(?11?I0J`2tzW2Jd3?cTvo=*}D>!yQ>tfF%4}AQ@wYCX=*zayK5yZ z&19{JX+G#uwT+4vn;F_pCZBJmnWg2G$b3HE8Z%p)$&?DZ9PO~8HD+6F#89$yrW%XQ zGqu@FR~m1a?X~$#b3oTY+srf$bRD(5Ox1>CovnoplciJ}Yv404SJ7g#i&nY*)B)Y9syZB&$H_0o1KYHJm0yNTq?*IVl_9BY>|UvF)Rq64Cj zc92NUe0{Z|5ojrAzH_v3L^$)EWu2ofXC2Ob{k82x3!I_8Ue>u<7`><)X@FIvl@ZDF z;UC(3MORw`v>HW~)*x-aq9fV`TGGYjC!HM^YEu-AG6!orCDGY2M9aN|Ea~hh(WXlh z>wQPXFl|2*o*lz9r<5#3E&NLCFfGW0=gKgxj0n$_D$s3IbhmYp7I7)&TOd||?h>s+ z(cRW%+B&8U-YTn1i@!`-Zt&i1U8$8bZT2p(MrlhF{mZJ*>X_=ik6G7h!OLa7dhavV z7_E%yWA6*rby|lqsr%Ubu64aOkZGTHhc#ZSQ?%EbsP!8uEsullR_&Ogz1Hp8@++in zF|=WtR&b?DcUyOABberc?k??+qPwkGT12_D^!XN8v$gSx{$X=eNcdyoOl(bCs z{mWXY)kuPK)l2R!>x` zy&U$V{ff5eIxMqR`!eh|`!%hG>3g6}+7_Zs0&93(+etJh{d%=d{R%(qKBNM28Kf=wTBKG%X{(VJ;bSD-JnQliPufTmA4|JKTxE^fL8XdKhE zO=pSS+C-*FOwIdB4_{FwKZa@qVN2C%PTl2Ukzp#Ou*gj-_w4 zYNFd|EPbc#Cz7o_pvB*SmYXyjF9)qc&d>lsVgbNL$G|Ec0irhUquR_p`Q+$&M;Bf7Uij63xN0 zU$mSX(a%~K*RMFgX!%6w=W_31ZK9$&?-A{oqK~}Cv<~AjANI>G?{RHD5$42 z_q`W>?ENOR+$4HLmx?gG1JN|mH~JAfOrObA6kP_o%}j%%j{~ z=K~coy&T;S^D(^@U5xpdwndj>zDY9QuILKPN3;prHxa0Ub;qJ-`kLysiWd4J^yFJG z-zL#I<}qKiKAY+6nAN_3zKCd==n<3Rjn#K5Di?8j*sZd@9x-KRyq>SUprK0bB8Tu|F7!xsveVO`x*7c1M{#N=iMUFpP&$~_5&^M-u zKSv)=w8k!s)ptpvGbdLsx*a{kGhn$lSFa+%Ga%W2rhZ6Knb}THn&Mh!`P=K` zh|tpUchqM~61jm6{ycphQ(>Ue?4)mI`bVIPzq4M?R2(SqchPq-T@>i;&({wzl?VF! zyXu~)vd=05=li?qF-*4vO8njRbf!B4m-q|x4ovd`BmF(}LZ$};SNnVF#Y{^BWBtAK zGNva3H~9ixj=*AEu8`^pSsrUZLo7 z|Hb-5MSK0F`bNb1Bx&3=ccORAZ^j=CoNE`1f#bIrCo zGxZv#mz#|Zzgw?k`Uvvfqt`Rx3i51yHxqutoUO;qprb-9nxl^)l6^KupUH%MHczi% zIy<2z{9e86F4?=Y6TS^!s4tu;>2v>)@I`t(6ZY;y`gSJl&xiG0OxV|t=(~wze=gPs z-YrYPBeqztV8Ys$>hqbf_GNm>tcKbj*X!?TsQpPjXSO7)eU+Zegtf2M^O&&q8atbL6RH{-+KCV{m-uWx63 zORRm9?l56}uj}bdSl=6Z5fj$;mcEw>>w8DveJ_?Gy?$Tc--t@?lQp0v=$NpS5A>vk zQisRrBYo}t4W)dn=RMGn?_+%n6XyF&KgNXlzR=75*^qCyzK&>KG;y-xB7M_%=f+SJS26P?~qPwg~ z-*0+YHR>>5v3*=mQdH!HN1}-qINf}!nrKEI(@@`5+te{uh3I@n zEs<=4+>`A%A_8Z%oen~mn)Nkw}x?NbQsEc_7Yq(v+rJ}AM)8(msBK*cmraOVc zjAKMtLyZVG!WPSXkENE1rba&^)RhC3NOCIDMn*&!rA#-ajRLA5S|FySjf;phmNVU( zHZ>y3*ewbAdR9cVv7c$E@7{7bHlR~>%;cF<7;We5G{ZR zhlorzl9>WPsYWi5TxZBIN~8|z3yaJ!s)%s)E|I~aS}66-t5h+pQm=;6qY zMxLT~e4ULFB5dDNkzI^3rT|b^V;qsJue-5D>Y%=tBD)*G*#sRq1K0 zC0ZaZPq(6a8S<5-3q(b_KdR6ueGK!-p6_ksu0+C~C>6a8dR~pF%4Qjjb0u#+$dt&;O!oDk+D$Gc~PatUZ(Ys?=mBPmCUyu z@{KeKnd-e`qpmc@D7qzTl(CTMWACh}tBms1GT+DE{e7Bb-NK!BTHFnlt)c9@|nEG%Tae2{g?tkcN!&3-F$CF-DQkXR3A0dn62oOsJo4| zMDm=TWyCy-HOTpMma$OL0dbFUkVvlc%{E3nhn8}D&NXHe;fVY)YOYboIy?jB8Db4u z;yT~AQS%K)(N9tL8Zkt2L@qFT^goTAOg~1Q8U3)a zo2f@kGav}bVSVteE65+Z3NwBV?5Iq&}}wWF>MFk z8%7<|ZqU79IO}DZ2SN9y5o9_Bx;KqdCMWA=>n)>-DJH8DXf0E6)--dAQP0#d>mnfW zk}R_bbZ;9;Od~+|w$YENB5Rg-$0%XKc;h=p?gp6;}e20w+MXyC4HCDdw>b6DyW^88a6FeM!+$h*8b$xPmu%F=?K1rV7xddv^U>>MB5&={d|)1-dNH+C5TN1-e$AI;Q)AKgDEw z2JVx(SA(&EGdv5wcIk{jd(T>?CasDBXM1YDk-8?WN&{UyyO=US*Uhtkztm-buBXTO zR?-=*MhAL(Iw+bD=_ggYI@uKSdJ)(>-NO z8$dVHvs}@Hz#LC4Qyutnucz>!ETsjF=Es(y57OW;}0BBt2v?SVC(wTgBJp7+!#`Zn-_=a8bqftNgC zhh!mGO%4*nL1+-zU$8=iQk&Y*kK zQ>w@pyTvn}sW7``?AxA+Kg)cD**URwp7~6JvwOzA@2USq>IP>Ih^_bRXBw6LZD5-x z=CIU_%03+U$dki#2ef^sr=OzTfloc9ioOke=9!}CaNysbMNIRuhs1vA*`laC_G`~x zMc2oE>*;qy);BMEM(husGNujL55)fLS*U1v>`_mRqGw`%^Q0e@`8H&~7OR^DOdn)# zjkV0Zihhg@H^Y9FmPTuTT(r4MQAS*XDUOj2uIsi%C!0x3R~m^isb(_M9MGki`Ap+L zmtht&RU4h+GR+D_-$e(_DT=m5XPebbD~<1>bIi4hwnd*|)-!pHUU9kRE~WrbJM$os zypro+9{Uablvi>c%qhoRIv~z67s36#Zp5~uxm`n&S8{pg5?$(c7{zgU<~Wbk;gwt` za|w~WTI*~^z;l}TjrQ`?`{O#BSAsulGiW!=3Yf>{Q2e~N#g6)UHsk54i=WO zKt$v$i|cMyF=gdE8`s;M&6Ee!*Q_SOGS|nQW5&RJ&zP?mbVX)4)1;jGxB=!yrhn#q z6?dMwn+Ws$7&p+I?Z_749iQi$hnTQ^=bPnTsl#uygUtCv)0`i2ocKZJBBtXxs9VAm z)&^-MQzB6f(^*98mm{5eM5(`R?O+?a;5tn2;T5Twa-az(m5>Q zTBZfb?K(G0xK7apol_HTFsD!{a`cQhXEq`%#f@^qt4xS6$~__h-wJ{{jB=MH+@k2R z@G%Kf%=xO6axvAcS9G;C&Gdv}FJXNt+6*&E(GhK?nWN~ggjr@$xNAAeoMWz%M0e)Q zHDj8Pj_%BvXHJwPw&s_Ld(B`|(!uxQIp)3Q7^eHpg$ehX6BTvR7MSxD_0aA!s}-HA z-EXc`^hm-#&9#aiPgrEuDta#AA+t`==7fKlI~Bc`@QAsWXo0BFcO)z}iz3i7q^}Yl zHK#LulK*|ea&woW;|VLw{77l}dA>LC33H~RxWrZFE~W#Zd)iFGxBftx2lC?*pEXA? zZOu=AmXTtxw!!<|hz2)y5l%o6YfxzDju0tYPvRTNAgK8<_$?@0fK&^316- z^Whye?)+J2Zd7zYyk`cJP$$0$zi%!ilJjT1xt4W1j878l&0Va+`DL3K(VWVJaaJxq zFmn}ES|6I_ijHX8&4r4-PuyYFD!SVG#N4fDl=-=t56|m>pALSr`NAw>O7DuagsF4a zG9b}XS{8PlW`1E-FyVKgFU*Zh_#NoqW_&VPihp!16?@D=Cj6eW$6UhnQ%o7qZl)nn z!yYp^MdrgXzsH=&gkye>xt0jOp&U)zW5%SSC6X^`ubIoV0(4)SGZp!gzBQLK)#$NF z2h81y(vp5Kk10Buc*tCdKOIUV*_ZT-xtXcno0oLN6zNh|?=4LF)r@Bv*>!NzF|$}v zMUrlfWBNzeyd>LNsi-i?Yt=G+l0PX4UagWL%lst&uB33Qh-o_HYijLRRG1WLc`~Kt z+^oE$C@Wr3VN#5h%e2pXZ&JWY&XShfUD3v*46B;yp{{QxWmy}uWxj{Hevs74+Rij8`?I8MYj$g? z86tIgvc4hgmyWx5K!h`7o>GOj#zL z)5ERlMDm(wgmsWeev*u^;DH_}6QA~YqWQ&En4(VFC04qkbG1?{SJ5L0ms$N3J=^?p zt60&7<|D0AMVfx4HD1wM&9AbiEBd7QwbnvKmuh3JRf@iEUTLjUbhP>P)@DWJ+KtvO zMP`ff)_z4zTHI_MCc+i#W-TUKp7z*2j1Dwwaf=m0B>TF`DkYMAU1hCQbU;kD4iU+| zzRl{;LG~wJbxpBG5aCKCPqo$($-bUuZ6?CL&Wf65?Um$o=yp`hunsbH z?N(;au#PeH0o`4e=PWuZ&H&KeWkoOz2Hi|6o~aacGp%%{t3Y?RmBVyB=j5~lf}yT>YLdKh%~SmTN0YW-}ho(bDN$4c)g`*W!8tQK>ueu}!am}^aB z@)~_x%(J#I1%U3gwiC&IxzE~5g#B{0b)V&&EnC~6TbcN$6~WZCTRBh?QylhLCM47qV zayn5@0L^Iem=z<*ncDrRc-%^2n$>+4P!7`rM0rHGetl1i$E^Y)9G?qXtgwoSq}MC0 z3MTaW32PkZ^BNDfc*2^_6aae4s%A_47P8tpNCfMH-AjR-&giE+nyan&E=ZHX>mu)J zD@Y_;^t6?yXtnPds~?d(|7xs>Qb*6S)mR%@hn_ua)v<1eQQzWOYd7og9DB}+$(MaS z)%du@8mj}-mBv>sp11Ot=78=6tAuGB=+;>kOx4E07VE7kijKC}U@c-=X&i0wvQ@+6 zH9Rd}wKg&ZfL^oen1=eAw0zy#r6|yHvvp8WQp-22!-~>czG;cB((7)%?3Qm?VT#Ud zxy6c6)T!m$Ryq;(V5xY=8mOp8%Xh2_Mg3a7Yb_$eyG+h&`JS~|>B?JfwGI<)Dp+1{ zUds=xU^lFNn)6)2oaF6RE|ENb+bvMgcdi`;4}va_bPL3ef+fixTZK#*#rV`JV(J^c zBKcFRR8dXxE^9nfkC+w7yRDguYLdUSmJrPoVLdh^e{Iz<<@9(vdB5f9j-H|J?i!m2Mu8 zW*;UU9?uqeyfado*(()2kdkEAGp&bwE$l;zo=HiuBMM~=_1^Uj-%rW3S1Q_@l4EaS`q+CUV@`frYj2vrIy(F{iN>7!mCp+wns2c2HoX$)j3i( z8FZuUYNo|-jIOm0DS9B~Iy<7jw44vRO1n(a11UGyRZKGrXQYg`cPV-xWrBT-X>r!H z)JgWbb7d*3fo`?SiXWwE`JX%6U?*q%XDiUZGjr95gUF;yFxY0K<9MbD%>W*0N9G@eOW zVUJ<*8o6mt*b|uoKu_5-nY#Hpr>(XZDe9H>w7rT*eyTlVA0(1jmCx8k7oaal2SklM zok(6)K5N$#$t(CZ_CeO|FpARF*g3_RPkw5zwMP)i`TBXgmPpPv&)Yi{4K`n}4=Jij zTW`l-NVUUEG|Jpymr0_zXQRD@3Fn@T_I@UudtSEl21~DT?s?U&V8XfQReK>5&ONW% zdzon-sx%Y+vSQDrfstqF|CJuAKJBwR;TT-_cGOcUrgI+hYgiw)_Y%1`_#^18riij z?K69wqA%0-*gKg%_WqLgwOut#=KI*|Pyfzd#I&<;dfNB4GhFI+7A{OXWT!I?C`?HI z*&d@Pn100G$TS3WzuKM=GT)HGVEXTN5z{C63F*R_s3@3jIIEbp=D(O`I<<;kPqUpm zrhVRa>5kLkB3b4>Z?E()XCTvY&^2}TD(aOU?RYMhmRA-IOpkSTDjJoZ-|#lYgnyE!G#NwRK9E=7a7`XN#hRX&s!sOkWgEOz-FvUncW? zQ8+ifyEC52={+&MuX9Y%-1LD?^5xQUCiHcQvs}@_wBb%I)8edW(=T$Slu66gK$kc< zBPAWluS>twDZ0X?UFl^`xgs;;3MaqZ)dey}IWePL%E+j2auuDKaji3-X=!1PjO(1* ztEA=9!t*o6IlB~HlyQSoc(v5kg5^!lc17oBOmq$@x+voor=)@`VLn@!HrbiUbfxin z+U?G4ra7RS;?y#Y1Kl)dH&eB7O~xILbB!#e+E|@-r<23966h{xAd}a)G2?D$1XBR$ z9;bq-n{RT)9A}E685wh(`9yL)o9FB%lJnU-r}$c|PtIraooXUEpWW*mBa-vkeNOsl zw8U>A^D^#prVz>bY@t&_Bd1RHN_BSnaG;^ixKSvzuvycT2`| zPVV(G-v;l_jOU#yruC5TMQ4?wpE6!@b~4p_k7sOjoEv1mdapn86(^TzWY?I?SDn3z zvNPXsoExR($KEcP?>O5PotOE(bBJj`;l-KToZ|7)azJ54=5}W-(-6?@a3XG!x*?$Z z#HnEVB>&>f&z$9oDl)%t4l!-bKc2DMiN9Iq+nVps{L)Eh+ULC?^DAeGqB}CbaW*m? z2i=q&Fcrp0iK z{N9Q)2Ad25-DW<{^&P?)pZg=TmW()7`DK3eu6z}$_E=6Redk-l}%F6VXOd}o43_CMgd6zR?Y4|f+ zdsi~e0bP#w7}Ge=o#9QtL*}bCa2Fth2l|OaY*? zy|ql;d<9vZygL=0lhxUKm`KhHUA)E9u|7F7bn$LibU@^LbMHi*oEf@$7ZJ&sp}V(^ zbvukfS>3%wGtg4b3{;!uEXk5AV;N*4z{KWdtcQ&qWYFqm z2}_o&l^-Gyc_ppo#Vf76yRt1Bf)pTuLIVW2fh435$b$qLXlO%jNNZB333;@nr8h6% zhBiqrBx&C1CGY$He=}##SxFX;Bz@dpZS6NR-+c4U%r~!ZzL|55o*AN%=9?Ku%fdbt zjdV)rf2hmbuU{LD?9GSnT-zGS=}T;P$C)CXOd?53lt?!=;a} z?TXwfT&P(cUwc{P841m*k)|t7-5yc5=-OW1{<*cikq321O4b)SCZXeMrsL~t`y$Vp z&_f9AjLiIzq!Y^i$esDnT~>eOK^+Qzxbr>XSmcBW9Ybg!QuS6z7k(C@U6F1R`acNm zj$Cg-zd~qFHZL**GJk+=w46`Mc!aSe}d4y$m1sTNrd8&@0!rF2n|Qp+^)I2fY3an*a-o7e4+l)R1Uj;kvX8jEZ&p(H{FBHboLStlcX z5}H+$h`TCsz=UQIIvANTp*s*tMea7C`w<$CJZeIJiqJ&lGbZ#DLg~nJCiHg*O-5cc zp?^l`P^A10mTXr2@UlDBWg_b&bR0e8(RJBK&0RX~;_drX4*kqh0U&I=lbZfA@mGtV z3Jc#k`^w4M!KJ@b=$3Uz>yb5x`PNof z0tVEG%)J_aK>RlfygLtVGxxfq*z0>PhNX4=uO^nc+v;y3URoDJ&ZCw$+vsxY*ndI^ z1L|8y<(Sb?h-cdGfyP!p5y}^Rl!f?LM)}*B-!~ z{EgJtFC}6MDgAu>elJzwYJ0L-TCYbZOZBHHv#r?E0@Bl*f}W;ZiZqsbLg0V*y2bma z+frW7aWVe(T{u=t`@dGN^Y^P)+5>+iJxX)X{(F{i4te(y%IcQ_uPR~x%mP~K0fGNh z;Io1!eL#IZkAe0j{tHT(YB5S%d1)QRT!QL?QX9FDo2y67<)iuALLUG?dCQ0la#ck!CTe0t*XrC>>=W4|w{{!K6%&c~C+RvW73)@Z(zepi_J zWzcf#M;UCT%Snu_{N>lVGp(g46D>n6VOMT*C1$C{<)r-mLbuG!#g-NiNXZ>j7me5D z|F7%UZKTW3mI@Tqjay7fk8q0VLD9Np6T%cjdujHA4=+3J0#7M4@z<(81SxF!GZyiO*= zm&Us?^rY=?qrw*Pxcyg4rB`SFdaZk)AL`ZLuWkOx8C=ajat3?a*90CqlYR}k-r4Fd z!T9;;k*J{`zmOh9ZtfnRex17>M_)LL{QnlvT@CXbYGLleze0WcrTGNZSAOT*9QBQb zc)rZCUA2a_I3!TZ%B!_5t;_%Sp|>-~lkW#zX)mVh{yz4Si|70DVi)K$`CfFgy_+kI zx&6w`(c|gw)h|b9{;IUEhTn(ZRzC%F*EsrZqxE_I!u3w4(yOHBFQn1s*BVaS*(|Le z-YOUkpA^4_-x0qbYP_!F=GU-nO@IN_4Ctsfz@X{`#CKl+L#hujtOfuh@|A#Mbp`xO z)IPuxH40cN-wP;HDfpMFNx*WI1GLPl?U&~(_0PAT{J~n5`C33rdH#UdH}I{XwVc!b z2GCL`#7_*qI|8ePt)7QJpnfQ6i`S9QGC)gRApR}lcl*P_%20%7}jpS z<)_eY<5_+R@l0EYS&VXiF8{t5w&o*70xajBNo#&VTJ{8BKz#?$Q9lQbYX@E^mbG4S z4!Plju1Iy}IbN*`@vn?>lkjX3o~?k6>H=rCBn!oo|3dhePUZGemVZq0ng9$c=36BB zhRnYBr6^g3m!h#TOXywpOHsc18ofF>JdXO>>IuMr)V)yV3&pa83*kMPFBJQ`m(oi~ z@|DS)rv|Rggf@13SN2>=MxQ3=wsSFz)w89>b3L_Gq2A(+h(i3rX#+mXGfyXZM(LI3 zWSE^&LQ=YCG%ki5IFq|IdS2%9Hwry%DFOASbG;H4;+b~-yi`~VFKr>7X+I#jFh{N< z9%UikqkI(f0hE^Go%HT_*Yt(4UaH?8|8Gh8e=Mb9863qj1f_&UQbKnuzZ4})`%*Ms zFMTOWa`XE9yd8nG+FTkx{cq!cIXa$yXY{`FICky@L{C1S@GL;==z$3cp5Gs(R6h+^ zr2bAQ{i*!^%Oq_tpiXNEAD6%0)9DhvAbIKC)BIF!390P_x3D}*0P#I(Ku4_x465_D zoIF;iav{^&N^4)Ad`UlaUC`i5&w0v|V@PQWWdL6sWZBvQgZSbgIV?d5Z50>4-)5`J zL;8TwJ9&C?n~M*M1-Pid0<1O94>ytiF~ETO2q5$XKubrNW~7r@x+Q-A^W zd5JyQPR%0($T*Z*o_ z=dTy~WLE3XdR=fa%qy^!wb1jh#usn(@^vvDWijZv$}kmU-BVz_*0?1n-tRxzIMpq? zFtmO9cU$ZO0fU)4xButeiL@wmXLrt1W7vTC}2>{K;}h;^5is>>iiYZm9y7s zE@ol+`5b6<246;r$XNd(v;e-W8Iq`Y-JtGJ16ce`bz8WNz#=ecSBfhajVUd{gJD0_$lZ6 z^~&qF_MEIF8vpywW#&@0poV&W@Y`2UR<=J8ORpd5KI88p{&>?=hWWbwg=5_o_hMblZ<}`h zDl>mZedTK(<@0iGJ-K;#^>Q(+m+N0R_N64|tzWv0UjC}|@+ox*({1cm)zCAcC%_+6 z^VhG1X#8~~2d!zitJ}+60T-9U;<0z4wA9Hx3A-4UO^-y5*+Rdj@oTCshLn1Y>-{x3 zSW3sfvu$oJ??mn{J^ca6(NZ6iQu*m!%)<2CQ`pK+?_w6FcV)s@-8bfAephqv%h48e z8N4~ff6Asc>i?cqbW6RwS;cKlufMq%w)o<+%HpvupM^QkpG#lTG{OOJhZ$|x(pFdq| zgVvP1I|hX|ij&!z+!`%B(ie}_IlelZ(&B07&oJ(M<>?Rqt*z-DP2r5{&HM{#Vsmw^ zg=jnu)b#!%w6*^zea!9c-sql>`S%>}`hMW++gYA*KwD|Q-U&C zr316V|0dN}d~wlDDp7nH;6Z_h0B;wbjNKTz319!YtY{}N`_w(^lH$P-;epUY>V_pp zL(}TLOKt~zddc0u|J{-g14aUW8hT3o(~>7Z6Dj#L;3~k!fd394OZx)g>Trcco@WSr zTK%}}>hL*M_0pTePpeH!uMXE){3>j>;6=9#Ct` zf35~pUHNz5ZvnKdUFAOwx2eX`pNG38wp-mAu_E2-Gr?tm@3+4N{HCSLBKN4DmbXS8 zQok`1>mgNJu_tl`Fr&eT)cF+&_?gQUlJ+5WQN=;fFGo!uQoAY+MY^o( zD&MNQtUD_4{5HPJ_es1Oi?!>r9;*B(VxO!Wf@J=-@~Oz6_4Uf1t3m7Am4A)Aeq8yv zNF0=RS%mwf)iTA01QWIR9nev!=_u|Q$4W+VFL`gt?bh*Au7LmRr;Gyf+j=R`*x^B| zbj8tR$jJTJcw<936LA(`xwCua({78ejbz`UGjPLPs{IF z_IZ4V^A5mU*L|<5PW|yY99gT+B|H<5qq1kkLu%suF96_5X>$#+VQUG}r* zC(66*ub*F3%u;=C1?g3F9Iy2bZ@QcY<=V*=(od|u$3DI2I4~zJ{p@P? z?a?6NW5xHVaC7w%OG@~Vl!X4?(;u_HT{(C<{rlkmC9x zi5URzpo^kES1*ZL{Bmm4;x}%e7S3N3_!V+f|73Tzzj5sk?dRKvLP=ok@DJ@Dx9sN=2pjv1eP|Dnyd3s`|)sefI2M&RQe|F-rf^~H`~ zuH6!NuESclCGamDp>;Q@p8yjDjkWHFHcNO;fbYEgp_KES0N-)BB@o$GvF-(vR|%fQ z-wFDUE_uOTe%ZB1wMJm$W%&BD&1dspuzy*>nO z!}o~)et{1Od`#fS1U@D3X+V4}8SB#;z_2<8utcrLuUs_%R;kT^)oLr^l=b$quyU*& z;jju@?}ER?x*xDg@YRB^5&Rm#tP{-ng4ryXCc!idrcKgzT3-c+ZtLrS1J(jA%O-30gp>#cx4vF-qT(YhP( zm)5<2%6<=^W4|9TY(ETGVm}60ZvQ!8mHlzR8k_R3wJHBKHs!z0ru@&hDZ>pmW!Pwc z3Y44e&jL2te+$@bKMUAqQzo4@Wil$M4v0S`X(#Pid06G_y?{sUD*@ji{AZ9?2~_Y+ z%g{pt7XyX^&449=cEIw$Wy?b9U4g3Vkh(9h0`S4Wsem5{tO9&EPz(5I;4Hw$1Fr#m zB5)4ilY#RAj|DCSJRYbA{7hgY;O7NC6W9#@vw<^9L+ZJxCHRIKoszsfi}SB z1KR+<8@LSc2Z0{Ip9J~fsGLDS$GHM9>&i#O+&Vzsloc9B!oDTv{I*$P6oJRqVIv)XigY)NrGtS2V zuXmmVywUkfz+0S80^a6)3h++nGk|wHp96fC^EZI^IbQ^P(0LZ{1J0KKA9lV9_^9*0 z0Uvjs1AM~y2H=y8OD&i4U7@B9ex8Rw^f&pIyxe%bj2;0fo~fX_MB zO32@F0H1e4fZuhB0e|3>0{+A)2Yk_42KYu40ZW2s0+t8Q2CNFM z1FR072Urta4_F(l16&hq1Y8%q2=M&iYXLU|w*oc>n*lcmTLGJb9e~ZjF2J^6H(+P5 z7qC0n57-yn1vn7g3%ED0M}uLs;0j027aM*$B6#{g5os{kj1e0}S za0G8pd{ zTbOg#ong*hcZWH5y(`SQ>%Q>nb(oFAX90d7ybkc;@CEBo^6+O-s>dbm6XAN`pA26F zcno~jDy1%lyB_W@LhH|=8weMP`-@PsaVL#CDDF2xUs^}HuZ5lv_d6k%e!0Z|I8zuzr`p>D$i@ssp z5ghewx7LKOGwuVfYb*6StZ#p1+%p17#So6dB|dK4S>xVs+^38?5>)DD=alllg8L!o z)8*d~_whn(11-w^j5XVWDr7Q6K*u_ zMX(s~-)7@(G4932Z8CIi#%(ulhjDipx7WCR!tEmhA6G4~DvYb6>KgSH_0Q@&>t^c- z>z}Q&?9KKb`&RqQc5`4?;5~u=6WHqXIpfZ)&MCok@QuM+g3kp%TQm~Ng#Iw}fzWWc zB=X_NFCunvadBDksm13OZz^sn-cfvc@&4lLi|;IcPw|CI?phKpd90+p^oG*=OFvs0 zC|g-pU)EgKS$28ZNLi|Es%)n0rn0Xr{l}%>S{f)XE}tmBru=>7AFEK6<&_&N-%|OW z%8F&Z%f^@8x2&aVxa!)fKdySFDzdzJ`QytgPT6$I{VR^I_}Yq}ulT!_Z#=c*w6W9P zeA<1d{rPDZ)b!M>S#{y+-K!s8{ps3&s12NP${BAw^H0uvaLprYo?7$WHOF4_*0t|m z`!8!RTlbE2Ww1Ey5_vvddL|^Zs*~_sfm;N23fv=btnO5F;)~kBhaT;L5X++ybVZ-T!{iaK8gT8HT-O6gl7O1TZ7KQ{V#vKP2!Y0zWSBGXlTpgh2Tff!`GP zV}ZXC7z{GDOyG(jI=4Dg;03{Q_%9OJBCt>3k>XuNN@@7oB@^hdcb8)-Ru7hw&xgzF z;eWh*6W|kqdAi~)@c&K4Er4GVs4*3l#5^M(@%pmB=LEh`MV>#cs#&7cF9imd6SI6d zF*^2J;=j6jIo^8ky_GY7zg)@OL#NVz_L-z_II|q@DR|(lPXHb%4&dqis`FllXQx*R zTrKb{f$Icr5V%=jv%t>t;-J4=;QsT-->v%?@S_)$;hF033s{T80%rxjUEq5JJ}OYB z(j30Dm3+Rrm2LO!t>mv`KX?iGd|2Q|1b$55F@b+A@Pn5y)rSRsMBv8+9uxT20)Kod z`Mh{3b5YHNpK5-4EhI1b>by?ozoz{IYs=MoJcSTe7Xb2JPC)u|0GPp`gPwdjAaA+{ zfe!c@t_(uUP_GBX?QGyI>=Prv4+V>X-v@|ywjsvGGj&UV zj|aJ@90tS_8^GDHdzQjC8Z1NX2%v=#v=sOXz;d-eSPpyw5Kp!NR}Q_c5|}YS8)Ix4 z{K;Sy@K*uS-nty{6pTC@zmNLQW7@amOuBQW@rp^Fdqs{_68~<(f8Z0w5e&-f0MwQVX3vTJi|`FUkhld9rhUfJ%EVMd2`0oPb?W#lY zzg^%xb{3d-0OHPwJq7=}0Qm;KBk;c)&{ltJPs4v7psnt={{a5?0NSuGUjzSp?Q7wG zP~iLQSzz7|Xv6Aq9pGyNHvnE7cne@t;3mMWftvv@3H%Y@rGZ-k_XTc8syLvn-Ws?A z@YcXxfVTzS4tRUu9>BK+-U*sJ1b!!QFEHO0_}#!C1OKmpw)$S+e)zu+Xk*X$0Q^4$ zwAGIS?}h)zfOw}=;QjFb6cBG#3p@n>Zv);g;I{=j&WC{s0^-!bc?|v# zAV#P25%?p3wyJdg3~-tAQNSwaV}MQ0#{u^`p8yqk~^aJ1;Hq3gn*4*&1)m67g}bje?q ze68fP(lbjh#2|g4yrtsp6{lA2TlOzihfn?HY42TiboDi796jqV&mLZb6S&Q+b;>7H-gb8H-5YTSOxND8O&A460 z-EQ22#!ZW>)E^l48iW6_qxt>Rxc}F*2l`zoNj=;-bL4p&Q|!fcq(RbIGUFH%qP#>@54W zv#ab4aR1G@H}oU?euCeN`28He*Qu-4;Vpd7a@WWz#WgB|Uon15@GHTu6u&b3mf}~A zUj=@Z_$|lp6#Q1;SB>9F{7%EK2ESGKt;X+k{8a2fJTuw0cl~H8<@(ilb|jriC5KgP zI-5(38)yBVtdfn#v|J4fVoiJbQQ~lM`<`l`zPIiOfVI z)ljdRdeWm)sl+8JIx&_?#E>?XP`l%)sl>qaWI}bdrpG7anfNfUKL5Tt)zyAzDxPBm z11v;5CqdPg7|SFQswX)yl}o5tVkA8=s`}%j$@m12sZ=tf{o9PIovd0vl1pb)TuP8* z=JCu(cVc2JcR-P3Dyw?p@OQPhxA!N;zxIHAT8xuO2V;dE*$ zmrPG&Rd!DJFe@iix}ciE^|vOHDGIP7l}2I6OV>kFxqjkx#WddaOWsmDldth>KKZJ< z%zOw^7=h^6e1I`s+5Y6%ft-}5D;vvY;=W+VR4Ub<&c#_>L(w~&N**$`?8-(**btge z?{E%%!vy*h`%{Ud5@0*0661*pok?tJ(hZ`{DwWuuQyIy#Cw^2#M@Lm`Y8b^B$*G>H zR4zH0npSPe!^u(2`tn33EgedDOWD1kTYL}WuYty7b;R|&qve|(H z=uL>(mPy2OiHsX`qk1!vd=7;VyK5qzneI!WQ-O&Db|l8M2!TKa(U~Al_}z+{V7|JD zVvV!JM>AtnlwJGLk;J4V)Z->GkXGs30rXQTPFA%-SW}rq*Tnv`J7l+|(!;3e)n5Cx zPGvG+W@wcelmlr9j$N~N_^JftZbEwGxg)SIlV&4i)P5O|#>rz_lDXFO#Nk8+B2#VY zDU9BMbk{^~QzK%sYFi@L8P6VQO`{pp!&fQ)FmeZoI|SS=-*39OZ)Ag!JEq-^>+7^# zS$}h@uB_Wx-Hu9(bW$YN9n{x3eI3*5WWEko*tz^U>5kQso|+hi6kF0qIYTAKr^Yd@ z92IxmgvU)7;%H4{p3GzwWCRCd&tfi`R-?&mEEX z)>fhm&|ozmsS9^9yeWECYFuZ8SC5HAOSjL<$VKHd@gZ1;;WTOq;3f9w>=J97$+bT| z?X{{dVRSeP0s7Dgu)XUD>I<;z1qef=9gi-b&D;o&soV3lK*7{Sm^|EIK@KibC(=?^(4lJ6Pai(mq`wb z{w7N2dYOqw%+dzdjVhX&JP=oL4Ved};1f%uFpsL%$w{+f4NaiPhxOEfsj6!N<(%X+ zD1lsGPAgnH3aBXbLQFwu*W@S!KB@|ksQtLfvkPN?GMyC#wkMv+9*9G+HdTViljDi? z(!bM_u|(!@awL&eJEsyEJqPTMV~XE4l|S|M5q*N4wI~=EW+bZfx*MwO<@(TeZFyfY(a)1H?i5mwi3fG$cL@E)7?xt(RMaERJ zHJ(Zh$43sTp^?c+U%*34@9OGm8|vCMad0AiWI~~9>NFEmZ13LvZn~aC?m&7}bO9H| zQsxs*>e6X4==v$DO$jwF$>zw8T~6f=B(b22$^rpSPUTFkB+}GL{Od<#15habdr&jpBObnyC%lt6Y;UcXvfrq zbZnV@{9T`kpekSx9>#JidY&{(z67T9`7rgA^aN;48&O+pXIkAWGT13e5aT3^#=^QQ z69{&1IW!+)P0!?tj2PsYUB4{>1tdA51`eR>jDj$i9PvhHlh?hommC}#Y5^bQ+L278 zMpZY~Q7~nxlBq;SIB~Fe$>)p&moh&TnxKYK_Q5MX+R*_O7-nC?qYD*U{tzC_|6W@3{#I+aVS_VG#VqDDnr zi5}hOF*edu8P0ZjT9wPE%D6Ih%b;COqELlB5s6G#VXu9?={`T?hV)mv3v}T#3v{c@raz%&{(Tkj<&g; zp<(Pc)eu&IY>P?9K_rvgP?n9rQlN?16tb{VdZzPmteM;-Ub$>#KY}F-%Sc~xVj?kW znrk3!=2R$K)Q`y9Sah}}a$;q|?)K_L?|v~@nG(4bfvfAma&=9#Oy|)1#^VPQt?9{W zwIiM5C`w~vGwLaB9oW$yz=Qxf5WtEP&xsE`Mcmi{q!3?A8s;z<5lE*MIcWHKKQ%}f z-za{JF|Am}N5!kLo$=IuiKa(0pid{KPm{rNl}TbB0G>NxHiPv|%nAGVqu*fVr}D=* zQA1%eOC0QlwFSB&)+)?3qrH;}t?qd>C6P*Ns#qdt#Hs}*Q1jBmTqNIWItW_K+uE%9OmnqYluCfi% zn>78`?IFPFW`~EZ4o5dSJZ_uA>o$4b+dxWZS(9v^0Fa zhDOM3T4?zkW-ZX;<{$NF0TR#qsS=uhApgmZb_~wdhUDYo zvzEFHn+i9%mjhNQnqgoBlm!tROH8NO6S<}|@%M`PF00%EVv|REu@tYt<>?|7`m?Vh zN)I-f4P6!A6Pv5m6t>-Z-Q??`awR=0pvM;m#8H@JpmK1I7S`xYh1-byJV@Dl&3O{E z^3=b$yUWWeFPUn(WMoM6rc`_yyVh*BPLxP#n7k1(H=nH0BcsrbeKHGu3CigFZs=y| z>zQglNu`k`QC|6KON^xAG=7Qz*zS2L<}tJu#z%W6V2LJyFvv%`+2;j_%{8{hUj4PU z=W8v_clmg|e4$mKH@OSfh&u)`bLWvUH@0^|`c13otI%iSL`E=E#w zz@igEGnEYqtmbYJruE2BEMS9Iz;XYKBGaN5$DkL|Q>7R7CQJ`!rs=r|Uw+<_2%;?3 zbQ}jkOYG*R!c6C0>L{(5BJOrFPP<7x01ZN7}iNjb51P*N(s>}Q8^S%b-tJ{E?RujVOQr6W0+lNU} zj?o6vlhAj@rcsvB#D2(f6#EQ_f%7dkmJ^V#@o=0^D$J&$(hAxQ=qQ(ZPcnA^<}27# zCPt=(hr}16-K6BRaLfXU`r=UH-4u0f!Av?O#l^(tkE>rKj$P_x=^7V_+qg*FrbXf| zS|o1sB5_+5iL2YNSma`osas4mb&JWSZZYB1Ehe41#l%y$n0)FM6Hwh^5~^QJLiLMD zsD3dC)h{NY`o$zvznFyT7n4x^ViKxfOhWaGNvL5l2{kMxp@umU!n}r~NY~V`JDE7r z27Bv-95opQp1K_7uDUjr_vy9P1nct=^=)$^#2}c3Q9XsZDNpXl79_y5YKU5=h7+!T z1pc_}P1}#=V2MwRnu4`8v|)K3hmK5NhKI~8*g6jx3oiXi_RHK*(^RXe#aP^y7@iu_ zn!8v?gqR8(Y~RMlt#fhL1nMgqBYOj^(S`AOgx)&H#@$WpPX{A)US;9+5lFu$J^}+Y zZ2LId)Vus4V+I#(A%l{0LWO3PHa3zd8b}SfRHA?S5^FoV7cb@kF6&r25+ibq*oK`e zPBvj_$|bYexSTATBUb2f$?-T&LXDZ!pj)8cW~M!?K8Kx0tkH9b-BdjIl$!}s&33(eUNIhMw6H)6A{jT9 z^N_Iv$^AKv-8C^ul?5h6I{Vcws4Y-O=+tdeG_vsSOB_1iE-d$I3P6i!Ke5^i+D6&N zx_j?VYGZN{=;~@5QwLXB8Y4s3D9=B{2K*XTPd&o*2-hQAk8lIRXoa2zgc}fUM7R;*MuZ#nNgb?}ID+RmphreW z`bfQtsdq6AE~df7G`bkg2Rn+X@d?e!^^=?SYlg1h!)vx0uQ_YKX72h)KY*T*P04mx ztM`)qd@O0@9M(tW4>P_in-^gweFTO$79F!CdMQq7F@ezlhYb+aTVx7LQ$qD-a6UGc zHb(#wn&4dop2_b zgAbJ(!TmY<+;}YvL!twQ$^_ggLnYjKcGo1#Lt3?-!bX~RhE#X@$UGdfX~$s?CQKor zNf)OS7-yqXBMBD59~++opG&sIB^`upq>-lHECK$ z$0AqkYm7M-B}^ZT=DIsoVmhI4R*n`^QI7d(MOV_xEFXJA@|d+p1^{xuHFwI zjpNc`y3|)>kYG5S!|opk9+R3T9|z(-?BOPP_;xq}N?!(~d^Jq{*jWEZ4vUsD(Q&J`NTCQcSX`B?ovgKa(+ne_d=6#pvebJ-Itinwu zG@t2h-u^m|8jR}`kbal})O7p^dL}%+!K9-5x%(5$ez{XdyCH8jutaV@HkXeUqNN7M zPChTONn=>KWt>Bd)aZ3}1Te0rk2DZ8LK1q8(JoDe3^y3J(O&`6zx*TLH|qDq4=32w zVKj7i;i5r~Cot2iBl%b!a&dIx(k!lLiqhE+l~92o6CX>+*#vrqz7&T$COF58qVaIu z1ga1tBnbv22D~V7Msw%}6YPcu(&Qi!dH!_Z^4wHa+;j7)* zL~2rX4Ue}T&WSOzJdkhmEIeJgzZ4?339^*iUpgmP}yhqW#-0 zs&6pqpnb=3ql#L12Q=a~n3dCG$&ox`VY6E_b)BMh7cYE{sKNMn{D9#X!vdFSRc+bH zZJG4cCRH=mt32I6=6u!1}YIr(2f=i9r@lA;D$xcWDTtv?$j!MaR#YIdqSXy=;N=+gWDuqsz z5|1f;o}@JcHhZGG+lM-O`+K4TLpyq6L%Un{M%(&YdkP|2V?$j%(fRoH*3RBoYeNBT ze{bvdJ?-7yL-Wb=QEgq@x(1@%+Y1uzZEtCBEx@3W>K0%F^yZ<~_U^s{;+`1WRP{_I z#tQKL1JLLEwd{+w3RQP}8h8E+qPlmrw(l4i5=QsG%2x-Ew0Y3qvhbw>va*qBU*S_TK&hoaqG+jg|K zEl3b;-Fy=KoKE0!jJ9I7@t4?(s4wg`Zp1uE`y#e1$O})J7SFE>VAlAEU$HD>`*tw~YyeBrV0%)Wy(SlO+?Cu)Eudrxs9qclN(jqR_!-49r zL|3dUx~mPh5d6sA9o=2K3;Rv1rFBlPZR_oB861kXHVno3+PXRl81%Habwy*nJGxru zciq1J-dJzj;LzsnEq#SO`0~NM?F)_4zRs@huD;k%cVBBuOF=#uIos!SubyakTl8IDPvo+uzwf(A(d>cY#jc)gK)wpxxcIyLWz#1RLw>Z{JZs zZ03~t^s(rU!QP?nwgqyGbwNDc(H6+Hy{~&mdtvte*zUf@%^M2avM_q{?!u`gA1lJ} zOQ0a8uy^I7wzqfh?kcPwd)WLbb?2^VcWZA?&rsj4{`TFyU9E-vC?DM!?e2hh3u6a% zwV;m{NUIAN>ubkaRXA@fKrm;t?&@ssUw|`&+CR|V-`3t*SQreO9ovU? z7tZtj(LETkz5Rtx^4(+y)ol=SH}mhCby}Z9V?9n*bk!yWGha0daMI_vr6sn)K-(! z{ykzuN$qdPhI~>#2$j`_ zy)b-7Gp?KS5_E3dls7jX z&Egz62Mq6QXrEY@VVLX2j+54j+&BkBrT~Kt9t)>yn;XZmfInzzm>Z|DnO8T+pT`-v zvNakNBhTLXs6n7QXs;tH_`BnIuX(7#M6_fQ@q@;1WSASz%WxD)Wz&6-Ld=cNkw|Ww zDJfN+V`+gz&2tZKFGZ30JOUqUP`ntNgoM1FCzlN{tfZ%Ox;KIuhjwKX8D6d6`mNX44}DSu`DdEJWwarIXo7Ioh;7HBUx zUSjpoAX58?Goy}3d? z$U&)wie|HTbjsX5|2EalwQyr`^8A&VQj$Bs%9|5BD;fp4~C=;CeY`O`2RVzu>?Qk0|pp zcgD*d=K)yu@i-moqR+QwVxYiuv7|CSFHiK)r*UtaceYI{j3#jCmxT!^>)q=fNXw;e zMwzRQ9KJky5mD%qe0@;w-r>#16QK!G`fUL$&t7Sp;XqDWG0C?oC9fzDc%Oi zU!#PjcvuXmTK;$>kj;QI%=oCe7TuOgp-1DmbHaDcot>&XIh^5bJiIDGmPsFO2;eylxR2l_CjpjxT4`%U`a`O>pNi>RwounA(f)d8bKtZ@+ zP8cT%62Al8Z#2<{$0BgZJvxVIqemo$cw-4S*!BsY*e{TLN7{^LEFgv!N+pS-@pwUE zFU*O;RT<1U)CJUXHK_^&!t2p8lXyd4A9;9>LSv25&l|ccU?-0^u`Y6L!9rN)dLXWN zZd_g`fz?i*M&X%pc`Pr#AbTe?zLk8$Th#MQxmntEX&`wRfaRXCJhg|Z=5js>d$~G- zmz#|8au9kVqqq*>l7bE>ow^aFp{j`!L9DV+gZPdVt=Qlhd+*f29deujdg4iaipgCF zAJN39A`fcJ^0efB;z`N#AgDdY(K+R*P^zQTdY7UzR6~+*=!m?3#jHg`lRQf?P3Nju zL#|>!l*9uyI8fw_!z+f8t4WEQ!ACgAs5ByjhI+l4m{J&e>R@i#{lKA0ST><}@czFN zRX&Et97KCFbP~ua{d}wmu(G~%FA|z{_EqUYS!sLPEh`j$ndx+h00DTRQHsc}9Ry=Woqa-}Wiq#fV9<_9mw4`_$ zC6?xvGQ%f$_#PV*uMt`v(v*98hGJcpw=04n?1O24Ytx~gt{q)HK)b={-Z{ZoXYU?E z8r|F3)dmAn4-6Nuxxknd?Zajlrl;OL?fotNz0tN-m|BRz&UsgBXB3-vWIY(8fhr0k zL|+Sx9(_G1!mb|tV3hHYJ9oAB54yNm>rfBOnJB36RtU#nu4&&9!)b-;+0i=G+T9y# z#}PT7v^2+ncsB)i9kNRHq|tfM&&`9xz#`C=!0T7|Trq+@Y23ZRqa6o0qS+!sc}<5Bo5w&IwOdCw;0wXoI_bP97NJT`@$5BdUoAtIzyq9erd7-m7KGWrqB z0-Pc8m)0ZmV@Wut9)@rZmV|R^Xb9(ENjSIehH@^Nq<*m&GCxX4#Drj^#&G+VvJ*dIs^ZhVYFg`LJ#kT+_g?;Uoh!0%x}vr8+{Mjn0SK z(UiRtR2O6z7xWZKQP5X`@l?gLWa+qqU&l2S7>X;1Wp(w05 z-ty^2Vj&yFd!{nDgMyh#UWPz+NqzSS&wj^`ite2C;$;^CdqbAzt61srN(6segY|Iv ztdcpX1$j~zEv27WpxjuLa3d$TP>RWE*&fc1qC&VEms=LBEBeg-Gk0+y5PSwIUrLcF0Zy2~*mBt0bT7+@cPr^~qjj0s;c&GJ} zG-3|GpMjt6t33<DDmL;DAPs+p3zZOzSgGVji*_TE-`Wr+dOfd@1N0qv=OZ-U~SXico)6^p66zCY6 z0iSXBHsF_ozZUNcJRgueVXKq+CQ%NN{lq=$MI9&6X7Pd^@+xH0wE>d%|Gyv~ z^7~p1*2DSJG^$N_9Wi?*`)mv3xgY;!glwm|Er(wWkZl#0)=p!jU4;;AqtZ)8fS+W?yD6=U5(-el#I)3^;dWYYL8ew@lz4 zdu9CD>+~qnv&Diue~bFFWLcE_YPeGWKrLRAz8AkirOx3v)1xyfrC?u3LF(>^8%H=t zsh!S|$(phc6PFZ84Vc+Yt(t@k(lXP*3JmOS;bi8Nz~#tq4_+kQgBhpJxb?k+7Iq1gcpPO; zqR#ARL-Nk>^@vH~zdEfARBf22bn9|1<*dM7r@F|03w)cwg=M_}p*n;%!`BG>2H-D1 zh;JZgY#d=?haug~YNMoL?^o%6k9mddoI^>_l7sYf4VXK(x-_qPKDltOZyp&GKi8L9 zJOaR3RL`q>#4j`IwTso9efB8Itmoy0=GD0r?3s(NI9w|^R>_$&!O0}yr(0Ya`0Cfm z=hqNN#1X6<{o-;RbJtAvJgzU}D6@Zk)8maLbX(_D&h4fC98|@AaLmZ~)n!qCpk-eR ziQ!cs_)(A1+5*RZA@zJc0JmR3Pib=8=-HBW|#Y)IMMG|D2q19%PqmH7R*Y2qZf+iy2V6uvShzw;g~sd;j#1b%kZkjQ$hWlJCg~F zC9Wx|)s@QJm|BcAJvs|DGNv4pxg)QU&z|-=Y-Fe!cv}^Q>wSv|!wtTLgyF{gVsa&> z1M;ByKpu^<@Gz`-Y|Mu>k4^co=5Z0iE)S|0J%1WR!3N@Knw& zg6!2CPIa%I)67k7wT?g&WW`|9hv@LU05YZ~$#JEdlg*1eJgBx_qjcj@v&f?Iq|p`6 zLWsi!!e^ZB9vo5BSGe!d8a(6JQPd$l>bSPepJBWmr>k#pyy`u=7x&WoQXkTggRGvf zJDIlRQ7x`3EwU4Zt;5X;7KjU@A|E}tT72?s^~tSG{Gvx1UFP>Ii=Cp+Xnlt}K}r<5 zOyXoxS&05s%V%RB@}s`%?z`9zw0zotWz9KIb*UI9cAeH;GCVo^9)XWqSqA_0M6nJ7 zupi$W*Wl|cYWaH5xT(CIksr%G%{}3m@K>jAgPZfE z>Oq+Lnx;?}N0CoVMnwiArVTl_)znFlAT2=-#1_a`6_gJNe$B6z^u2x>G7@#lpL9HS>_W z_%2MqN>hAsG0)9iHMALn4MXL>7DDBcj%#0N9Ctn8u%w}rU1u%@=_pjsSmH0VKW_|_ z6$@_;l~I8g9=yzfF~19QqrYLq;CRyQUm@kDWo2joYi@A=cImL z$+!`qw#yR0GPJaiR;e3b{K}=ve!XwU4XF>@{P$%mKdizZz50sXD;uA?Dg5ZAL)TXP zL-A{imRFWq6=66PaO|QIC%$CU#ZLSBmd(y(wY?ji>wb3TCC;<|{F*IJ@t4lJ7$1(S zn7KYwYg;97gLF#*A*&>)?9$Rw81XFpN}O5?s8FD!q{P9IL8%k6OG+Z45W@Ud6msZ* z(spVUGFQmDB8+c`(WwaIV~G{vkg_GnJj%+zF4K#uc9^}_Wx372?9Drf%XELXW#E|j30MM6PJLm@IRDG`XS zz}A&wqVW7WCKet_W0P=!WHku?AU zf9QE7B`B*)TFvsJ9B#P0+#f4>of0b6X#uq?#Dk9&xry>^S5EQF$AW%osMJ>$c=K77 zl$Ss(CJ_bDMf6JBQ z<3w)!<;MU@=;c%pD2MP-TsBJHS6+!vqf3K$Jwrz#Z;TJH;!tA_D6AV`!CilzNUA9X zy%BNvt71WsS|Z$Xx+#Iob759`a8(!82GGtN^z4Nk&YYvHRh$?(x=RqWt#C;w6pZj+ z5OW^rFj6^2SDB%L&cQzpm1_Pkmi}6eYT$$0f};d597x512b!hIF$j(3IAuc3p`yAp zA5S(BH-fW8MRkcV7S3c>!=Oxl;#Q-GLFS_8Ti^l}?cuP@)$JA4m{0i)NMzLRtV0bW zmU6oI9R{U^QWL6mC=?@=W~pIJglM-mw zlnFJ5iW*&0#*+YmRa{Qgc&vQ=;}j z(NYWFowL~9)u69NuohpD4_Qks1eaRXSZ1naW?F;tgwbq+<<&9~!$sGqwpZihu~y~Q ziYvJa4m!mazB#tR!k5P|)K=B3R(25>+jccOKuzV=RW(KB7HFz5uY{`uMU_o6`_D3D|FD< zl?nb28GK2(6MW_ONp->YPI znD~#2|G4;1i2nrrvsLs1Dt;k4P;3Puf$*weI2>X@R;?D1!wI7##gPpbA`u9qn8g({ ze}*nuOqZ=&Oi)CTu$*+N1=a{^<_YaQshwlmIj)@(;>=c2`jR)B7x{1$R7SA`sr_hdo6eOHtOiX3VD+eeS?U3eE=;3FCFqO@Gp>it` zUw|aaFwig}zKB__tg_rj@^8UiA0BiOH{#FH09GyF- zx&S*3>K#}b3R2oLKSh8m1NIdRRBnY_;Jc@C=4VT49g|S7;-C4|@=&-i2g#&56q$#W zh|*9Iazm>~2xFH;zak7(aOMOu#K11$Y`RrrfTU-(3Q^+O3{NrZTR98SNV?f3H?kQX zPJ7ooSVy4J5%5c{#N9}63zo;~%9-1^O3vJdRS=^R9=L!@ErUIRx+X(I;xR2m|f=2<6;$2QLiSdzf<&+TcyRpt01ZNVQMX-k8Y=YMitR+}S028Eg z&LudH;CzA$2w+lD&V>ZHL!lhl`IUnkA83a0$Vs1kD5}_u14}%ABD9T=8TyqDX=FvB;e2|c|3^-3oXx$#mtlZ=^UOs(^9Jz;LBI2 z&S8A41WSbGnP+>fV&<4(dJIgt5~0|~PQsKgr=7#}_)@Ied8T>3$17%z!+;VF8|KHs zoa-ByA3q6mzTDPj9w=HB!7qegP*&;BqusD^Q&xzEm~bQlt53uT>=_E|8EOwu^|_u| ztHSJCSoGAYu-BmZx>Bn&JYFB_4e; z+`e?RDlWG$HkMk@N3n7^^kVhEf?tjg-#eeU=*=6QuPyCr26$S)r3_w*0Y|C`62pbh zNbv-vc%mY-lp7%5zh$-MvM2JPO0Ym+jL3ouqf4kr$1OpZg-A~Dx3o5Iv#H{a)U<-c zFRWgk$*Lz zGB#~kQc89{aC&Gd*ql6mL+F%~N3!TXUJ_g$Dy=HP2h^dH>x2*`glKTkg35s~-3%3) zZDuOE+Hk>s1B=GORwh)Lwty3wNJCl*Bn_Zu>scVkTKcV*0-vCk_GVN>m{D@23ieX@ zNBk1SzM{i=u+S)lsc*=L&(HVK>j37d-1kVvUs zW=Z`froYOW=Smgy%;yjzojQcA^UQPZ9DxlKgNQ`_HPz5*sSP~`yMrBuStx+ry$ux9 zrspulTV*JoRXKaM%&X6blv7q#L#w0H4$jCFeFc>*$5f62 zD7#A8%awhKvR7b#tL&A^hWY*sWuK|+vy{C?*=H;JHOgMA>~+fCpzJzj*DJe0*^SEH zsO(M3zDU`dmAysTuT}QN%5GBjR%JIUJF4s!W%nt&U)eEb?^5=lviB)FuIyoDk0^Uo z*$HKjDLbj`No5~Wc1GD*W#^PVrR>AXKBDZS%AQvCjIw8y{U&8!r|j#MeS@;!tn3?= zeUq|pSN7YKeTTB|RQB7IeYdjjQTBbxzF*nzQT7AMeh~8r_FHI8sFjv|mSvx9+1L@) zS$4f;H&}L~WpA|XX3Org?46dq%d+=bcHFXuEql_k4_S7`va^;AS>j&++J$Y`+V%$9 zZno{HZTH#sPTSsR+mjG>z=p!x=h!nv_H2=@$}!zDL7?1r%57C)t14S9w^gnE>)+VW zs(Q!lzA<~}n4KQ8C&%nVW2VFWK-%>O(0eOpe!$N3P0Tr%C1;&#^c~Cqt{;n_c+sNJ z5jR%MhA~EsuW}aiLa-V}3;dz$t`xLa)Y?S>aGl*k5O#h}E$>Bw9}s+(;5!6A z0f5pV9G27;!E6Lp+HwTDl3o>QEiTT_BPF6hxpQfx7PHYU9LA^@v@* zk~3U+Rfy166?!=x3pI!;Lj|#69nJF{;ejI-rog1(ah7EXhe9}fk+dE=Of<6FlGR$X z&}%pdL5wBn6_ZNRycIAqzGI++?2*RE^CrkI5~wt zo+7m>Qz9-KX2nC{ga-uRFkziBc!5hLI%?BD1@H5Id4#j_QDO$}5H$!a+V z&DKh6ZN+Rgq3HDYQbH~Xk^ABqku5{)SwVpTL&v$Q9WBScl9xne}-}$xU*%3UDpBz5FcDH_5aBKbg z4g7z8ZL9v^+t!K16y64qI={AWY8dZ<+MdAsiw`Cywhmu(QGDab#!Yow8X6NDHgAF5 zd|=nLudF0|mBH_{5J7o4!VC-tVwPAVTGJXRFIa(2lsvTSe7pl`VTdPDxvra(u6;7(`n(@(jc}55@&p8qqp1uY(p= zwEJPQpk*2zLxSaDbi8Uwc# zra!0yDCikD={S4 z!MwSdKc5`9y7=W#HRl*x%nwWhx~jsodQ&Gd#C8Z)0a;l!?aT?d&0ao2>&s^zttk5_ zE*R;#g0&EVW3Qq;%mh;bCYQ}?EOq*vS>3$rWB!y5?S|JdHoL2_=rX8{98zApWRdu=Tb2!&!+~)B1Tn()vxZ@-kZg%V*-%9D|^^dXPP^dU`R`VeDH9}>KjNcxb=+4P|T#zG~1$m0%1W(H|?yF|0E zNtm8}pxGyfD${%tS4dmf)XiQ~gH|`S78{z60z~t%ByRI*4;mB)Zkz?0PuhHbOKcD) zX|q${2BqOpC&ipp$BZIFt}Y~}2Gp(@vK zsjBAUR?B6sl3?6S0kh0onXb&MWgal~Q$5vZdP6zB$_TXhUJA5B9z}M*UVHRt> zrOv^d?-R9g^S-xQybh=q?-Z&vGqW3kx1QmECWv~$VhGDFT~%$VW%(IgUh@}|*X*bY zOO@m!_HOH%L)yTvk>S-7Ja0I~QWbep^T|k@>8!9+|fPI=DXnHXun9O(l-v?UWE) z4_=Xm3#6~H)ERu~o4l@~_LC3Q*5ll#b{-kaQ@6f>8mKNDUc7<#2PKr6dG~)7MR&P1 zV3)@ZCh;+w|JUC6q%;gfVf>}-(gV1Rpc@xb#f8fhsu<8zu!uWF%tA;-?4@+)1-yX^ z58%QZcmwtO%_L36C`9= zcuZZUqRUg=6KO}z^t~(f%CV(3vP}6@-wMp-T0ZvP-nlF2x*imGpgi($m!$JE_Z2}J zDi_HsVu!twah{6t?bIczTXj}r)k4LeiUVH9K=6(pdQWm1X-r;W4m-W=>CUyOglv6j zxh}v!{?=s+%Y5P(>~PJcgmNWb9Dr^Nedk0LwUP@_1}t`T)*&aI@}|X=w8^P^D9`@?r1S>K*)q<6*6v zc8Dxcqo095C6jCH2E9RH`dxT8}jJKhq{jF|Z=L1Nlc~S~v`EG)G3L z(Ax6maSh92yVpFo)HA}ucrFUy$oNL3U-Ss{R;@WXkLXY1^mrV}UavV9zUYhU*|qW8 mcKC(uzoOX25X=X`P9RdxJUiCo*Xg+ + + + SharpDX + + + + + Represents a unit independant angle using a single-precision floating-point + internal representation. + + + + + A value that specifies the size of a single degree. + + + + + A value that specifies the size of a single minute. + + + + + A value that specifies the size of a single second. + + + + + A value that specifies the size of a single radian. + + + + + A value that specifies the size of a single milliradian. + + + + + A value that specifies the size of a single gradian. + + + + + The internal representation of the angle. + + + + + Initializes a new instance of the SharpDX.AngleSingle structure with the + given unit dependant angle and unit type. + + A unit dependant measure of the angle. + The type of unit the angle argument is. + + + + Initializes a new instance of the SharpDX.AngleSingle structure using the + arc length formula (θ = s/r). + + The measure of the arc. + The radius of the circle. + + + + Wraps this SharpDX.AngleSingle to be in the range [π, -π]. + + + + + Wraps this SharpDX.AngleSingle to be in the range [0, 2π). + + + + + Wraps the SharpDX.AngleSingle given in the value argument to be in the range [π, -π]. + + A SharpDX.AngleSingle to wrap. + The SharpDX.AngleSingle that is wrapped. + + + + Wraps the SharpDX.AngleSingle given in the value argument to be in the range [0, 2π). + + A SharpDX.AngleSingle to wrap. + The SharpDX.AngleSingle that is wrapped. + + + + Compares two SharpDX.AngleSingle instances and returns the smaller angle. + + The first SharpDX.AngleSingle instance to compare. + The second SharpDX.AngleSingle instance to compare. + The smaller of the two given SharpDX.AngleSingle instances. + + + + Compares two SharpDX.AngleSingle instances and returns the greater angle. + + The first SharpDX.AngleSingle instance to compare. + The second SharpDX.AngleSingle instance to compare. + The greater of the two given SharpDX.AngleSingle instances. + + + + Adds two SharpDX.AngleSingle objects and returns the result. + + The first object to add. + The second object to add. + The value of the two objects added together. + + + + Subtracts two SharpDX.AngleSingle objects and returns the result. + + The first object to subtract. + The second object to subtract. + The value of the two objects subtracted. + + + + Multiplies two SharpDX.AngleSingle objects and returns the result. + + The first object to multiply. + The second object to multiply. + The value of the two objects multiplied together. + + + + Divides two SharpDX.AngleSingle objects and returns the result. + + The numerator object. + The denominator object. + The value of the two objects divided. + + + + Returns a System.Boolean that indicates whether the values of two SharpDX.Angle + objects are equal. + + The first object to compare. + The second object to compare. + True if the left and right parameters have the same value; otherwise, false. + + + + Returns a System.Boolean that indicates whether the values of two SharpDX.Angle + objects are not equal. + + The first object to compare. + The second object to compare. + True if the left and right parameters do not have the same value; otherwise, false. + + + + Returns a System.Boolean that indicates whether a SharpDX.Angle + object is less than another SharpDX.AngleSingle object. + + The first object to compare. + The second object to compare. + True if left is less than right; otherwise, false. + + + + Returns a System.Boolean that indicates whether a SharpDX.Angle + object is greater than another SharpDX.AngleSingle object. + + The first object to compare. + The second object to compare. + True if left is greater than right; otherwise, false. + + + + Returns a System.Boolean that indicates whether a SharpDX.Angle + object is less than or equal to another SharpDX.AngleSingle object. + + The first object to compare. + The second object to compare. + True if left is less than or equal to right; otherwise, false. + + + + Returns a System.Boolean that indicates whether a SharpDX.Angle + object is greater than or equal to another SharpDX.AngleSingle object. + + The first object to compare. + The second object to compare. + True if left is greater than or equal to right; otherwise, false. + + + + Returns the value of the SharpDX.AngleSingle operand. (The sign of + the operand is unchanged.) + + A SharpDX.AngleSingle object. + The value of the value parameter. + + + + Returns the the negated value of the SharpDX.AngleSingle operand. + + A SharpDX.AngleSingle object. + The negated value of the value parameter. + + + + Adds two SharpDX.AngleSingle objects and returns the result. + + The first object to add. + The second object to add. + The value of the two objects added together. + + + + Subtracts two SharpDX.AngleSingle objects and returns the result. + + The first object to subtract + The second object to subtract. + The value of the two objects subtracted. + + + + Multiplies two SharpDX.AngleSingle objects and returns the result. + + The first object to multiply. + The second object to multiply. + The value of the two objects multiplied together. + + + + Divides two SharpDX.AngleSingle objects and returns the result. + + The numerator object. + The denominator object. + The value of the two objects divided. + + + + Compares this instance to a specified object and returns an integer that + indicates whether the value of this instance is less than, equal to, or greater + than the value of the specified object. + + The object to compare. + + A signed integer that indicates the relationship of the current instance + to the obj parameter. If the value is less than zero, the current instance + is less than the other. If the value is zero, the current instance is equal + to the other. If the value is greater than zero, the current instance is + greater than the other. + + + + + Compares this instance to a second SharpDX.AngleSingle and returns + an integer that indicates whether the value of this instance is less than, + equal to, or greater than the value of the specified object. + + The object to compare. + + A signed integer that indicates the relationship of the current instance + to the obj parameter. If the value is less than zero, the current instance + is less than the other. If the value is zero, the current instance is equal + to the other. If the value is greater than zero, the current instance is + greater than the other. + + + + + Returns a value that indicates whether the current instance and a specified + SharpDX.AngleSingle object have the same value. + + The object to compare. + + Returns true if this SharpDX.AngleSingle object and another have the same value; + otherwise, false. + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Returns a hash code for this SharpDX.AngleSingle instance. + + A 32-bit signed integer hash code. + + + + Returns a value that indicates whether the current instance and a specified + object have the same value. + + The object to compare. + + Returns true if the obj parameter is a SharpDX.AngleSingle object or a type + capable of implicit conversion to a SharpDX.AngleSingle value, and + its value is equal to the value of the current SharpDX.Angle + object; otherwise, false. + + + + + Gets or sets the total number of revolutions this SharpDX.AngleSingle represents. + + + + + Gets or sets the total number of degrees this SharpDX.AngleSingle represents. + + + + + Gets or sets the minutes component of the degrees this SharpDX.AngleSingle represents. + When setting the minutes, if the value is in the range (-60, 60) the whole degrees are + not changed; otherwise, the whole degrees may be changed. Fractional values may set + the seconds component. + + + + + Gets or sets the seconds of the degrees this SharpDX.AngleSingle represents. + When setting te seconds, if the value is in the range (-60, 60) the whole minutes + or whole degrees are not changed; otherwise, the whole minutes or whole degrees + may be changed. + + + + + Gets or sets the total number of radians this SharpDX.AngleSingle represents. + + + + + Gets or sets the total number of milliradians this SharpDX.AngleSingle represents. + One milliradian is equal to 1/(2000π). + + + + + Gets or sets the total number of gradians this SharpDX.AngleSingle represents. + + + + + Gets a System.Boolean that determines whether this SharpDX.Angle + is a right angle (i.e. 90° or π/2). + + + + + Gets a System.Boolean that determines whether this SharpDX.Angle + is a straight angle (i.e. 180° or π). + + + + + Gets a System.Boolean that determines whether this SharpDX.Angle + is a full rotation angle (i.e. 360° or 2π). + + + + + Gets a System.Boolean that determines whether this SharpDX.Angle + is an oblique angle (i.e. is not 90° or a multiple of 90°). + + + + + Gets a System.Boolean that determines whether this SharpDX.Angle + is an acute angle (i.e. less than 90° but greater than 0°). + + + + + Gets a System.Boolean that determines whether this SharpDX.Angle + is an obtuse angle (i.e. greater than 90° but less than 180°). + + + + + Gets a System.Boolean that determines whether this SharpDX.Angle + is a reflex angle (i.e. greater than 180° but less than 360°). + + + + + Gets a SharpDX.AngleSingle instance that complements this angle (i.e. the two angles add to 90°). + + + + + Gets a SharpDX.AngleSingle instance that supplements this angle (i.e. the two angles add to 180°). + + + + + Gets a new SharpDX.AngleSingle instance that represents the zero angle (i.e. 0°). + + + + + Gets a new SharpDX.AngleSingle instance that represents the right angle (i.e. 90° or π/2). + + + + + Gets a new SharpDX.AngleSingle instance that represents the straight angle (i.e. 180° or π). + + + + + Gets a new SharpDX.AngleSingle instance that represents the full rotation angle (i.e. 360° or 2π). + + + + + Represents an axis-aligned bounding box in three dimensional space. + + + + + The minimum point of the box. + + + + + The maximum point of the box. + + + + + Initializes a new instance of the struct. + + The minimum vertex of the bounding box. + The maximum vertex of the bounding box. + + + + Retrieves the eight corners of the bounding box. + + An array of points representing the eight corners of the bounding box. + + + + Determines if there is an intersection between the current object and a . + + The ray to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The ray to test. + When the method completes, contains the distance of the intersection, + or 0 if there was no intersection. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The ray to test. + When the method completes, contains the point of intersection, + or if there was no intersection. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The plane to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The box to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The sphere to test. + Whether the two objects intersected. + + + + Determines whether the current objects contains a point. + + The point to test. + The type of containment the two objects have. + + + + Determines whether the current objects contains a . + + The box to test. + The type of containment the two objects have. + + + + Determines whether the current objects contains a . + + The sphere to test. + The type of containment the two objects have. + + + + Constructs a that fully contains the given points. + + The points that will be contained by the box. + When the method completes, contains the newly constructed bounding box. + Thrown when is null. + + + + Constructs a that fully contains the given points. + + The points that will be contained by the box. + The newly constructed bounding box. + Thrown when is null. + + + + Constructs a from a given sphere. + + The sphere that will designate the extents of the box. + When the method completes, contains the newly constructed bounding box. + + + + Constructs a from a given sphere. + + The sphere that will designate the extents of the box. + The newly constructed bounding box. + + + + Constructs a that is as large as the total combined area of the two specified boxes. + + The first box to merge. + The second box to merge. + When the method completes, contains the newly constructed bounding box. + + + + Constructs a that is as large as the total combined area of the two specified boxes. + + The first box to merge. + The second box to merge. + The newly constructed bounding box. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + true if has a different value than ; otherwise, false. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Represents a bounding sphere in three dimensional space. + + + + + The center of the sphere in three dimensional space. + + + + + The radious of the sphere. + + + + + Initializes a new instance of the struct. + + The center of the sphere in three dimensional space. + The radius of the sphere. + + + + Determines if there is an intersection between the current object and a . + + The ray to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The ray to test. + When the method completes, contains the distance of the intersection, + or 0 if there was no intersection. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The ray to test. + When the method completes, contains the point of intersection, + or if there was no intersection. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The plane to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a triangle. + + The first vertex of the triangle to test. + The second vertex of the triagnle to test. + The third vertex of the triangle to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The box to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The sphere to test. + Whether the two objects intersected. + + + + Determines whether the current objects contains a point. + + The point to test. + The type of containment the two objects have. + + + + Determines whether the current objects contains a triangle. + + The first vertex of the triangle to test. + The second vertex of the triagnle to test. + The third vertex of the triangle to test. + The type of containment the two objects have. + + + + Determines whether the current objects contains a . + + The box to test. + The type of containment the two objects have. + + + + Determines whether the current objects contains a . + + The sphere to test. + The type of containment the two objects have. + + + + Constructs a that fully contains the given points. + + The points that will be contained by the sphere. + When the method completes, contains the newly constructed bounding sphere. + + + + Constructs a that fully contains the given points. + + The points that will be contained by the sphere. + The newly constructed bounding sphere. + + + + Constructs a from a given box. + + The box that will designate the extents of the sphere. + When the method completes, the newly constructed bounding sphere. + + + + Constructs a from a given box. + + The box that will designate the extents of the sphere. + The newly constructed bounding sphere. + + + + Constructs a that is the as large as the total combined area of the two specified spheres. + + The first sphere to merge. + The second sphere to merge. + When the method completes, contains the newly constructed bounding sphere. + + + + Constructs a that is the as large as the total combined area of the two specified spheres. + + The first sphere to merge. + The second sphere to merge. + The newly constructed bounding sphere. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + true if has a different value than ; otherwise, false. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Contains static methods to help in determining intersections, containment, etc. + + + + + Determines the closest point between a point and a triangle. + + The point to test. + The first vertex to test. + The second vertex to test. + The third vertex to test. + When the method completes, contains the closest point between the two objects. + + + + Determines the closest point between a and a point. + + The plane to test. + The point to test. + When the method completes, contains the closest point between the two objects. + + + + Determines the closest point between a and a point. + + The box to test. + The point to test. + When the method completes, contains the closest point between the two objects. + + + + Determines the closest point between a and a point. + + + The point to test. + When the method completes, contains the closest point between the two objects; + or, if the point is directly in the center of the sphere, contains . + + + + Determines the closest point between a and a . + + The first sphere to test. + The second sphere to test. + When the method completes, contains the closest point between the two objects; + or, if the point is directly in the center of the sphere, contains . + + If the two spheres are overlapping, but not directly ontop of each other, the closest point + is the 'closest' point of intersection. This can also be considered is the deepest point of + intersection. + + + + + Determines the distance between a and a point. + + The plane to test. + The point to test. + The distance between the two objects. + + + + Determines the distance between a and a point. + + The box to test. + The point to test. + The distance between the two objects. + + + + Determines the distance between a and a . + + The first box to test. + The second box to test. + The distance between the two objects. + + + + Determines the distance between a and a point. + + The sphere to test. + The point to test. + The distance between the two objects. + + + + Determines the distance between a and a . + + The first sphere to test. + The second sphere to test. + The distance between the two objects. + + + + Determines whether there is an intersection between a and a point. + + The ray to test. + The point to test. + Whether the two objects intersect. + + + + Determines whether there is an intersection between a and a . + + The first ray to test. + The second ray to test. + When the method completes, contains the point of intersection, + or if there was no intersection. + Whether the two objects intersect. + + This method performs a ray vs ray intersection test based on the following formula + from Goldman. + s = det([o_2 - o_1, d_2, d_1 x d_2]) / ||d_1 x d_2||^2 + t = det([o_2 - o_1, d_1, d_1 x d_2]) / ||d_1 x d_2||^2 + Where o_1 is the position of the first ray, o_2 is the position of the second ray, + d_1 is the normalized direction of the first ray, d_2 is the normalized direction + of the second ray, det denotes the determinant of a matrix, x denotes the cross + product, [ ] denotes a matrix, and || || denotes the length or magnitude of a vector. + + + + + Determines whether there is an intersection between a and a . + + The ray to test. + The plane to test. + When the method completes, contains the distance of the intersection, + or 0 if there was no intersection. + Whether the two objects intersect. + + + + Determines whether there is an intersection between a and a . + + The ray to test. + The plane to test + When the method completes, contains the point of intersection, + or if there was no intersection. + Whether the two objects intersected. + + + + Determines whether there is an intersection between a and a triangle. + + The ray to test. + The first vertex of the triangle to test. + The second vertex of the triagnle to test. + The third vertex of the triangle to test. + When the method completes, contains the distance of the intersection, + or 0 if there was no intersection. + Whether the two objects intersected. + + This method tests if the ray intersects either the front or back of the triangle. + If the ray is parallel to the triangle's plane, no intersection is assumed to have + happened. If the intersection of the ray and the triangle is behind the origin of + the ray, no intersection is assumed to have happened. In both cases of assumptions, + this method returns false. + + + + + Determines whether there is an intersection between a and a triangle. + + The ray to test. + The first vertex of the triangle to test. + The second vertex of the triagnle to test. + The third vertex of the triangle to test. + When the method completes, contains the point of intersection, + or if there was no intersection. + Whether the two objects intersected. + + + + Determines whether there is an intersection between a and a . + + The ray to test. + The box to test. + When the method completes, contains the distance of the intersection, + or 0 if there was no intersection. + Whether the two objects intersected. + + + + Determines whether there is an intersection between a and a . + + The ray to test. + The box to test. + When the method completes, contains the point of intersection, + or if there was no intersection. + Whether the two objects intersected. + + + + Determines whether there is an intersection between a and a . + + The ray to test. + The sphere to test. + When the method completes, contains the distance of the intersection, + or 0 if there was no intersection. + Whether the two objects intersected. + + + + Determines whether there is an intersection between a and a . + + The ray to test. + The sphere to test. + When the method completes, contains the point of intersection, + or if there was no intersection. + Whether the two objects intersected. + + + + Determines whether there is an intersection between a and a point. + + The plane to test. + The point to test. + Whether the two objects intersected. + + + + Determines whether there is an intersection between a and a . + + The first plane to test. + The second plane to test. + Whether the two objects intersected. + + + + Determines whether there is an intersection between a and a . + + The first plane to test. + The second plane to test. + When the method completes, contains the line of intersection + as a , or a zero ray if there was no intersection. + Whether the two objects intersected. + + Although a ray is set to have an origin, the ray returned by this method is really + a line in three dimensions which has no real origin. The ray is considered valid when + both the positive direction is used and when the negative direction is used. + + + + + Determines whether there is an intersection between a and a triangle. + + The plane to test. + The first vertex of the triangle to test. + The second vertex of the triagnle to test. + The third vertex of the triangle to test. + Whether the two objects intersected. + + + + Determines whether there is an intersection between a and a . + + The plane to test. + The box to test. + Whether the two objects intersected. + + + + Determines whether there is an intersection between a and a . + + The plane to test. + The sphere to test. + Whether the two objects intersected. + + + + Determines whether there is an intersection between a and a . + + The first box to test. + The second box to test. + Whether the two objects intersected. + + + + Determines whether there is an intersection between a and a . + + The box to test. + The sphere to test. + Whether the two objects intersected. + + + + Determines whether there is an intersection between a and a triangle. + + The sphere to test. + The first vertex of the triangle to test. + The second vertex of the triagnle to test. + The third vertex of the triangle to test. + Whether the two objects intersected. + + + + Determines whether there is an intersection between a and a . + + First sphere to test. + Second sphere to test. + Whether the two objects intersected. + + + + Determines whether a contains a point. + + The box to test. + The point to test. + The type of containment the two objects have. + + + + Determines whether a contains a . + + The first box to test. + The second box to test. + The type of containment the two objects have. + + + + Determines whether a contains a . + + The box to test. + The sphere to test. + The type of containment the two objects have. + + + + Determines whether a contains a point. + + The sphere to test. + The point to test. + The type of containment the two objects have. + + + + Determines whether a contains a triangle. + + The sphere to test. + The first vertex of the triangle to test. + The second vertex of the triagnle to test. + The third vertex of the triangle to test. + The type of containment the two objects have. + + + + Determines whether a contains a . + + The sphere to test. + The box to test. + The type of containment the two objects have. + + + + Determines whether a contains a . + + The first sphere to test. + The second sphere to test. + The type of containment the two objects have. + + + + Represents a color in the form of rgb. + + + + + The red component of the color. + + + + + The green component of the color. + + + + + The blue component of the color. + + + + + Initializes a new instance of the struct. + + The value that will be assigned to all components. + + + + Initializes a new instance of the struct. + + The red component of the color. + The green component of the color. + The blue component of the color. + + + + Initializes a new instance of the struct. + + The red, green, and blue components of the color. + + + + Initializes a new instance of the struct. + + A packed integer containing all three color components. + The alpha component is ignored. + + + + Initializes a new instance of the struct. + + The values to assign to the red, green, and blue components of the color. This must be an array with three elements. + Thrown when is null. + Thrown when contains more or less than four elements. + + + + Converts the color into a packed integer. + + A packed integer containing all three color components. + The alpha channel is set to 255. + + + + Converts the color into a three component vector. + + A three component vector containing the red, green, and blue components of the color. + + + + Creates an array containing the elements of the color. + + A three-element array containing the components of the color. + + + + Adds two colors. + + The first color to add. + The second color to add. + When the method completes, completes the sum of the two colors. + + + + Adds two colors. + + The first color to add. + The second color to add. + The sum of the two colors. + + + + Subtracts two colors. + + The first color to subtract. + The second color to subtract. + WHen the method completes, contains the difference of the two colors. + + + + Subtracts two colors. + + The first color to subtract. + The second color to subtract + The difference of the two colors. + + + + Modulates two colors. + + The first color to modulate. + The second color to modulate. + When the method completes, contains the modulated color. + + + + Modulates two colors. + + The first color to modulate. + The second color to modulate. + The modulated color. + + + + Scales a color. + + The color to scale. + The amount by which to scale. + When the method completes, contains the scaled color. + + + + Scales a color. + + The color to scale. + The amount by which to scale. + The scaled color. + + + + Negates a color. + + The color to negate. + When the method completes, contains the negated color. + + + + Negates a color. + + The color to negate. + The negated color. + + + + Restricts a value to be within a specified range. + + The value to clamp. + The minimum value. + The maximum value. + When the method completes, contains the clamped value. + + + + Restricts a value to be within a specified range. + + The value to clamp. + The minimum value. + The maximum value. + The clamped value. + + + + Performs a linear interpolation between two colors. + + Start color. + End color. + Value between 0 and 1 indicating the weight of . + When the method completes, contains the linear interpolation of the two colors. + + This method performs the linear interpolation based on the following formula. + start + (end - start) * amount + Passing a value of 0 will cause to be returned; a value of 1 will cause to be returned. + + + + + Performs a linear interpolation between two colors. + + Start color. + End color. + Value between 0 and 1 indicating the weight of . + The linear interpolation of the two colors. + + This method performs the linear interpolation based on the following formula. + start + (end - start) * amount + Passing a value of 0 will cause to be returned; a value of 1 will cause to be returned. + + + + + Performs a cubic interpolation between two colors. + + Start color. + End color. + Value between 0 and 1 indicating the weight of . + When the method completes, contains the cubic interpolation of the two colors. + + + + Performs a cubic interpolation between two colors. + + Start color. + End color. + Value between 0 and 1 indicating the weight of . + The cubic interpolation of the two colors. + + + + Returns a color containing the smallest components of the specified colorss. + + The first source color. + The second source color. + When the method completes, contains an new color composed of the largest components of the source colorss. + + + + Returns a color containing the largest components of the specified colorss. + + The first source color. + The second source color. + A color containing the largest components of the source colors. + + + + Returns a color containing the smallest components of the specified colors. + + The first source color. + The second source color. + When the method completes, contains an new color composed of the smallest components of the source colors. + + + + Returns a color containing the smallest components of the specified colors. + + The first source color. + The second source color. + A color containing the smallest components of the source colors. + + + + Adjusts the contrast of a color. + + The color whose contrast is to be adjusted. + The amount by which to adjust the contrast. + When the method completes, contains the adjusted color. + + + + Adjusts the contrast of a color. + + The color whose contrast is to be adjusted. + The amount by which to adjust the contrast. + The adjusted color. + + + + Adjusts the saturation of a color. + + The color whose saturation is to be adjusted. + The amount by which to adjust the saturation. + When the method completes, contains the adjusted color. + + + + Adjusts the saturation of a color. + + The color whose saturation is to be adjusted. + The amount by which to adjust the saturation. + The adjusted color. + + + + Adds two colors. + + The first color to add. + The second color to add. + The sum of the two colors. + + + + Assert a color (return it unchanged). + + The color to assert (unchange). + The asserted (unchanged) color. + + + + Subtracts two colors. + + The first color to subtract. + The second color to subtract. + The difference of the two colors. + + + + Negates a color. + + The color to negate. + A negated color. + + + + Scales a color. + + The factor by which to scale the color. + The color to scale. + The scaled color. + + + + Scales a color. + + The factor by which to scale the color. + The color to scale. + The scaled color. + + + + Modulates two colors. + + The first color to modulate. + The second color to modulate. + The modulated color. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + true if has a different value than ; otherwise, false. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Gets or sets the component at the specified index. + + The value of the red, green, or blue component, depending on the index. + The index of the component to access. Use 0 for the red component, 1 for the green component, and 2 for the blue component. + The value of the component at the specified index. + Thrown when the is out of the range [0, 2]. + + + + Represents a color in the form of argb. + + + + + The red component of the color. + + + + + The green component of the color. + + + + + The blue component of the color. + + + + + The alpha component of the color. + + + + + Initializes a new instance of the struct. + + The value that will be assigned to all components. + + + + Initializes a new instance of the struct. + + The alpha component of the color. + The red component of the color. + The green component of the color. + The blue component of the color. + + + + Initializes a new instance of the struct. + + The red, green, blue, and alpha components of the color. + + + + Initializes a new instance of the struct. + + The red, green, and blue compoennts of the color. + The alpha component of the color. + + + + Initializes a new instance of the struct. + + A packed integer containing all four color components. + + + + Initializes a new instance of the struct. + + The values to assign to the alpha, red, green, and blue components of the color. This must be an array with four elements. + Thrown when is null. + Thrown when contains more or less than four elements. + + + + Converts the color into a packed integer. + + A packed integer containing all four color components. + + + + Converts the color into a three component vector. + + A three component vector containing the red, green, and blue components of the color. + + + + Converts the color into a four component vector. + + A four component vector containing all four color components. + + + + Creates an array containing the elements of the color. + + A four-element array containing the components of the color. + + + + Adds two colors. + + The first color to add. + The second color to add. + When the method completes, completes the sum of the two colors. + + + + Adds two colors. + + The first color to add. + The second color to add. + The sum of the two colors. + + + + Subtracts two colors. + + The first color to subtract. + The second color to subtract. + WHen the method completes, contains the difference of the two colors. + + + + Subtracts two colors. + + The first color to subtract. + The second color to subtract + The difference of the two colors. + + + + Modulates two colors. + + The first color to modulate. + The second color to modulate. + When the method completes, contains the modulated color. + + + + Modulates two colors. + + The first color to modulate. + The second color to modulate. + The modulated color. + + + + Scales a color. + + The color to scale. + The amount by which to scale. + When the method completes, contains the scaled color. + + + + Scales a color. + + The color to scale. + The amount by which to scale. + The scaled color. + + + + Negates a color. + + The color to negate. + When the method completes, contains the negated color. + + + + Negates a color. + + The color to negate. + The negated color. + + + + Restricts a value to be within a specified range. + + The value to clamp. + The minimum value. + The maximum value. + When the method completes, contains the clamped value. + + + + Restricts a value to be within a specified range. + + The value to clamp. + The minimum value. + The maximum value. + The clamped value. + + + + Performs a linear interpolation between two colors. + + Start color. + End color. + Value between 0 and 1 indicating the weight of . + When the method completes, contains the linear interpolation of the two colors. + + This method performs the linear interpolation based on the following formula. + start + (end - start) * amount + Passing a value of 0 will cause to be returned; a value of 1 will cause to be returned. + + + + + Performs a linear interpolation between two colors. + + Start color. + End color. + Value between 0 and 1 indicating the weight of . + The linear interpolation of the two colors. + + This method performs the linear interpolation based on the following formula. + start + (end - start) * amount + Passing a value of 0 will cause to be returned; a value of 1 will cause to be returned. + + + + + Performs a cubic interpolation between two colors. + + Start color. + End color. + Value between 0 and 1 indicating the weight of . + When the method completes, contains the cubic interpolation of the two colors. + + + + Performs a cubic interpolation between two colors. + + Start color. + End color. + Value between 0 and 1 indicating the weight of . + The cubic interpolation of the two colors. + + + + Returns a color containing the smallest components of the specified colorss. + + The first source color. + The second source color. + When the method completes, contains an new color composed of the largest components of the source colorss. + + + + Returns a color containing the largest components of the specified colorss. + + The first source color. + The second source color. + A color containing the largest components of the source colors. + + + + Returns a color containing the smallest components of the specified colors. + + The first source color. + The second source color. + When the method completes, contains an new color composed of the smallest components of the source colors. + + + + Returns a color containing the smallest components of the specified colors. + + The first source color. + The second source color. + A color containing the smallest components of the source colors. + + + + Adjusts the contrast of a color. + + The color whose contrast is to be adjusted. + The amount by which to adjust the contrast. + When the method completes, contains the adjusted color. + + + + Adjusts the contrast of a color. + + The color whose contrast is to be adjusted. + The amount by which to adjust the contrast. + The adjusted color. + + + + Adjusts the saturation of a color. + + The color whose saturation is to be adjusted. + The amount by which to adjust the saturation. + When the method completes, contains the adjusted color. + + + + Adjusts the saturation of a color. + + The color whose saturation is to be adjusted. + The amount by which to adjust the saturation. + The adjusted color. + + + + Adds two colors. + + The first color to add. + The second color to add. + The sum of the two colors. + + + + Assert a color (return it unchanged). + + The color to assert (unchange). + The asserted (unchanged) color. + + + + Subtracts two colors. + + The first color to subtract. + The second color to subtract. + The difference of the two colors. + + + + Negates a color. + + The color to negate. + A negated color. + + + + Scales a color. + + The factor by which to scale the color. + The color to scale. + The scaled color. + + + + Scales a color. + + The factor by which to scale the color. + The color to scale. + The scaled color. + + + + Modulates two colors. + + The first color to modulate. + The second color to modulate. + The modulated color. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + true if has a different value than ; otherwise, false. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Gets or sets the component at the specified index. + + The value of the alpha, red, green, or blue component, depending on the index. + The index of the component to access. Use 0 for the alpha component, 1 for the red component, 2 for the green component, and 3 for the blue component. + The value of the component at the specified index. + Thrown when the is out of the range [0, 3]. + + + + Root IUnknown class to interop with COM object + + + + + Root class for all Cpp interop object. + + + + + The native pointer + + + + + Fake Init Method. Force CppObject to initialize + + + + + + Default constructor. + + Pointer to Cpp Object + + + + Initializes a new instance of the class. + + + + + Method that could be modified by inherited class + + + + + Get a pointer to the underlying Cpp Object + + + + + Initializes a new instance of the class. + + Pointer to Cpp Object + + + + Initializes a new instance of the class. + + + + + Query Interface for a particular GUID. + + GUID query interface + output object associated with this GUID, IntPtr.Zero in interface is not supported + + + + Query Interface for a particular interface support. + + + + + + + Instantiate a ComObject from a native pointer. + + The ComObject class that will be returned + The native pointer to a com object. + An instance of T binded to the native pointer + + + + Increment COM reference + + Reference counter + + + + Release COM reference + + + + + + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + + + + + A COM Interface Callback + + + + + Default Constructor. + + the client callback + number of methods to allocate in the VTBL + + + + Gets a managed callback from an unknown. + + The PTR. + + + + + Add a method supported by this interface. This method is typically called from inherited constructor. + + the managed delegate method + + + + Base class for a framework component. This class can be used as a base component to provide: + + a way to create named disposable component which can be associated with some user tags. + a container for disposable objects, being able to dispose dependent disposable. + an automatic component container with todipose-region that will be able to add newly created components to a list of components to dispose. Use and to use this feature in a subclass container component. + + + + + + Thread local storage for ToDispose Collectors. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The name attached to this component + + + + Releases unmanaged resources and performs other cleanup operations before the + is reclaimed by garbage collection. + + + + + Releases unmanaged and - optionally - managed resources + + + + + Use this component as the collector for new components created in the current thread. + + + The collector push on the stack is local to the current executing thread. + + + + + Unuse this component as the collector for new components created in the current thread. + + + The collector push on the stack is local to the current executing thread. + + + + + Try to add this component to the latest component that started PushCollector + + + + + Disposes of object resources. + + If true, managed resources should be + disposed of in addition to unmanaged resources. + + + + Adds a disposable object to the list of the objects to dispose. + + To dispose. + + + + Removes a disposable object to the list of the objects to dispose. + + + To dispose. + + + + Occurs while this component is disposing and before it is disposed. + + + + + Gets or sets the disposables. + + The disposables. + + + + Gets or sets a value indicating whether this instance is attached to a collector. + + + true if this instance is attached to a collector; otherwise, false. + + + + + Gets the name of this component. + + The name. + + + + Gets or sets the tag associated to this object. + + The tag. + + + + Gets a value indicating whether this instance is disposed. + + + true if this instance is disposed; otherwise, false. + + + + + An Interface Callback + + + + + Default Constructor. + + number of methods to allocate in the VTBL + + + + Gets a managed callback from an unknown. + + The PTR. + + + + + Add a method supported by this interface. This method is typically called from inherited constructor. + + the managed delegate method + + + + A DataBox provides supporting information for a whose + data is organized within three dimensions (a box). + + None + + + + Initializes a new instance of the class. + + The row pitch, in bytes. + The slice pitch, in bytes. + The data. + + + + Gets the containing the actual data bytes. + + + + + Gets or sets the number of bytes of data between two consecutive (1D) rows of data. + + + + + Gets or sets the number of bytes of data between two consecutive (2D) slices of data. + + + + + A DataRectangle provides supporting information for a whose + data is organized within two dimensions (a rectangle). + + None + + + + Initializes a new instance of the class. + + The row pitch, in bytes. + The data. + + + + Gets the containing the actual data bytes. + + + + + Gets or sets the number of bytes of data between two consecutive (1D) rows of data. + + + + + Provides a stream interface to a buffer located in unmanaged memory. + + None + + + + Release any resource associated to this DataStream + + + + + Initializes a new instance of the class from a Blob buffer. + + The buffer. + + + + Initializes a new instance of the class, using a managed buffer as a backing store. + + A managed array to be used as a backing store. + + true if reading from the buffer should be allowed; otherwise, false. + + true if writing to the buffer should be allowed; otherwise, false. + + + + Initializes a new instance of the class, and allocates a new buffer to use as a backing store. + + The size of the buffer to be allocated, in bytes. + + true if reading from the buffer should be allowed; otherwise, false. + + true if writing to the buffer should be allowed; otherwise, false. + + + + Initializes a new instance of the class, using an unmanaged buffer as a backing store. + + A pointer to the buffer to be used as a backing store. + The size of the buffer provided, in bytes. + + true if reading from the buffer should be allowed; otherwise, false. + + true if writing to the buffer should be allowed; otherwise, false. + + + + Not supported. + + Always thrown. + + + + Reads a single value from the current stream and advances the current + position within this stream by the number of bytes read. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The type of the value to be read from the stream. + The value that was read. + This stream does not support reading. + + + + Reads a float. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + a float from the stream + + + + Reads a int. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + an int from the stream + + + + Reads a short. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + an short from the stream + + + + Reads a bool. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + an bool from the stream + + + + Reads a Vector2. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + an Vector2 from the stream + + + + Reads a Vector3. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + an Vector3 from the stream + + + + Reads a Vector4. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + an Vector4 from the stream + + + + Reads a Color3. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + an Color3 from the stream + + + + Reads a Color4. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + an Color4 from the stream + + + + Reads a Half. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + an Half from the stream + + + + Reads a Half2. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + an Half2 from the stream + + + + Reads a Half3. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + an Half3 from the stream + + + + Reads a Half4. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + an Half4 from the stream + + + + Reads a Matrix. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + a Matrix from the stream + + + + Reads a Quaternion. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + a Quaternion from the stream + + + + Reads a sequence of bytes from the current stream and advances the position + within the stream by the number of bytes read. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + An array of values to be read from the stream. + The zero-based byte offset in buffer at which to begin storing + the data read from the current stream. + The maximum number of bytes to be read from the current stream. + The number of bytes read from the stream. + This stream does not support reading. + + + + Reads an array of values from the current stream, and advances the current position + within this stream by the number of bytes written. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The type of the values to be read from the stream. + An array of values that was read from the current stream. + + + + Reads a sequence of elements from the current stream into a target buffer and + advances the position within the stream by the number of bytes read. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + An array of values to be read from the stream. + The zero-based byte offset in buffer at which to begin storing + the data read from the current stream. + The number of values to be read from the current stream. + The number of bytes read from the stream. + This stream does not support reading. + + + + Sets the position within the current stream. + + Attempted to seek outside of the bounds of the stream. + + + + Not supported. + + Always ignored. + Always thrown. + + + + Writes a single value to the stream, and advances the current position + within this stream by the number of bytes written. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The type of the value to be written to the stream. + The value to write to the stream. + The stream does not support writing. + + + + Writes the specified value. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The value. + + + + Writes the specified value. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The value. + + + + Writes the specified value. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The value. + + + + Writes the specified value. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The value. + + + + Writes the specified value. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The value. + + + + Writes the specified value. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The value. + + + + Writes the specified value. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The value. + + + + Writes the specified value. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The value. + + + + Writes the specified value. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The value. + + + + Writes the specified value. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The value. + + + + Writes the specified value. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The value. + + + + Writes the specified value. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The value. + + + + Writes the specified value. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The value. + + + + Writes the specified value. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The value. + + + + Writes the specified value. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The value. + + + + Writes a sequence of bytes to the current stream and advances the current + position within this stream by the number of bytes written. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + An array of bytes. This method copies count bytes from buffer to the current stream. + The zero-based byte offset in buffer at which to begin copying bytes to the current stream. + The number of bytes to be written to the current stream. + This stream does not support writing. + + + + Writes an array of values to the current stream, and advances the current position + within this stream by the number of bytes written. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + An array of values to be written to the current stream. + This stream does not support writing. + + + + Writes a range of bytes to the current stream, and advances the current position + within this stream by the number of bytes written. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + A pointer to the location to start copying from. + The number of bytes to copy from source to the current stream. + This stream does not support writing. + + + + Writes an array of values to the current stream, and advances the current position + within this stream by the number of bytes written. + + + In order to provide faster read/write, this operation doesn't check stream bound. + A client must carefully not read/write above the size of this datastream. + + The type of the values to be written to the stream. + An array of values to be written to the stream. + The zero-based offset in data at which to begin copying values to the current stream. + The number of values to be written to the current stream. If this is zero, + all of the contents will be written. + This stream does not support writing. + + + + Gets a value indicating whether the current stream supports reading. + + + true if the stream supports reading; otherwise, false. + + + + Gets a value indicating whether the current stream supports seeking. + + Always true. + + + + Gets a value indicating whether the current stream supports writing. + + + true if the stream supports writing; otherwise, false. + + + + Gets the internal pointer to the current stream's backing store. + + An IntPtr to the buffer being used as a backing store. + + + + Gets the length in bytes of the stream. + + A long value representing the length of the stream in bytes. + + + + Gets or sets the position within the current stream. + + The current position within the stream. + Stream Class + + + + Gets the position pointer. + + The position pointer. + + + + Gets the length of the remaining. + + The length of the remaining. + + + + Provides methods to perform fast read/write random access data on a buffer located in an unmanaged memory. + + + This class doesn't validate the position read/write from. It is the responsability of the client of this class + to verify that access is done within the size of the buffer. + + None + + + + Release any resource associated to this DataBuffer + + + + + Initializes a new instance of the class, using a managed buffer as a backing store. + + A managed array to be used as a backing store. + + + + Initializes a new instance of the class, and allocates a new buffer to use as a backing store. + + The size of the buffer to be allocated, in bytes. + + is less than 1. + + + + Initializes a new instance of the class, using an unmanaged buffer as a backing store. + + A pointer to the buffer to be used as a backing store. + The size of the buffer provided, in bytes. + + + + Gets a single value from the current buffer at the specified position. + + Relative position in bytes from the beginning of the buffer to get the data from. + The type of the value to be read from the buffer. + The value that was read. + + + + Gets a float. + + Relative position in bytes from the beginning of the buffer to get the data from. + a float from the buffer + + + + Gets a int. + + Relative position in bytes from the beginning of the buffer to get the data from. + an int from the buffer + + + + Gets a short. + + Relative position in bytes from the beginning of the buffer to get the data from. + an short from the buffer + + + + Gets a bool. + + Relative position in bytes from the beginning of the buffer to get the data from. + an bool from the buffer + + + + Gets a Vector2. + + Relative position in bytes from the beginning of the buffer to get the data from. + an Vector2 from the buffer + + + + Gets a Vector3. + + Relative position in bytes from the beginning of the buffer to get the data from. + an Vector3 from the buffer + + + + Gets a Vector4. + + Relative position in bytes from the beginning of the buffer to get the data from. + an Vector4 from the buffer + + + + Gets a Color3. + + Relative position in bytes from the beginning of the buffer to get the data from. + an Color3 from the buffer + + + + Gets a Color4. + + Relative position in bytes from the beginning of the buffer to get the data from. + an Color4 from the buffer + + + + Gets a Half. + + Relative position in bytes from the beginning of the buffer to get the data from. + an Half from the buffer + + + + Gets a Half2. + + Relative position in bytes from the beginning of the buffer to get the data from. + an Half2 from the buffer + + + + Gets a Half3. + + Relative position in bytes from the beginning of the buffer to get the data from. + an Half3 from the buffer + + + + Gets a Half4. + + Relative position in bytes from the beginning of the buffer to get the data from. + an Half4 from the buffer + + + + Gets a Matrix. + + Relative position in bytes from the beginning of the buffer to get the data from. + a Matrix from the buffer + + + + Gets a Quaternion. + + Relative position in bytes from the beginning of the buffer to get the data from. + a Quaternion from the buffer + + + + Gets an array of values from a position in the buffer. + + Relative position in bytes from the beginning of the buffer to get the data from. + number of T instance to get from the positionInBytes + The type of the values to be read from the buffer. + An array of values that was read from the current buffer. + + + + Gets a sequence of elements from a position in the buffer into a target buffer. + + Relative position in bytes from the beginning of the buffer to get the data from. + An array of values to be read from the buffer. + The zero-based byte offset in buffer at which to begin storing + the data read from the current buffer. + The number of values to be read from the current buffer. + + + + Sets a single value to the buffer at a specified position. + + The type of the value to be written to the buffer. + Relative position in bytes from the beginning of the buffer to set the data to. + The value to write to the buffer. + + + + Sets the specified value. + + Relative position in bytes from the beginning of the buffer to set the data to. + The value. + + + + Sets the specified value. + + Relative position in bytes from the beginning of the buffer to set the data to. + The value. + + + + Sets the specified value. + + Relative position in bytes from the beginning of the buffer to set the data to. + The value. + + + + Sets the specified value. + + Relative position in bytes from the beginning of the buffer to set the data to. + The value. + + + + Sets the specified value. + + Relative position in bytes from the beginning of the buffer to set the data to. + The value. + + + + Sets the specified value. + + Relative position in bytes from the beginning of the buffer to set the data to. + The value. + + + + Sets the specified value. + + Relative position in bytes from the beginning of the buffer to set the data to. + The value. + + + + Sets the specified value. + + Relative position in bytes from the beginning of the buffer to set the data to. + The value. + + + + Sets the specified value. + + Relative position in bytes from the beginning of the buffer to set the data to. + The value. + + + + Sets the specified value. + + Relative position in bytes from the beginning of the buffer to set the data to. + The value. + + + + Sets the specified value. + + Relative position in bytes from the beginning of the buffer to set the data to. + The value. + + + + Sets the specified value. + + Relative position in bytes from the beginning of the buffer to set the data to. + The value. + + + + Sets the specified value. + + Relative position in bytes from the beginning of the buffer to set the data to. + The value. + + + + Sets the specified value. + + Relative position in bytes from the beginning of the buffer to set the data to. + The value. + + + + Sets the specified value. + + Relative position in bytes from the beginning of the buffer to set the data to. + The value. + + + + Sets an array of values to a specified position into the buffer. + + Relative position in bytes from the beginning of the buffer to set the data to. + An array of values to be written to the current buffer. + + + + Sets a range of data to a specified position into the buffer. + + Relative position in bytes from the beginning of the buffer to set the data to. + A pointer to the location to start copying from. + The number of bytes to copy from source to the current buffer. + + + + Sets an array of values to a specified position into the buffer. + + The type of the values to be written to the buffer. + Relative position in bytes from the beginning of the buffer to set the data to. + An array of values to be written to the buffer. + The zero-based offset in data at which to begin copying values to the current buffer. + The number of values to be written to the current buffer. If this is zero, + all of the contents will be written. + + + + Gets a pointer to the buffer used as a backing store.. + + An IntPtr to the buffer being used as a backing store. + + + + Gets the length in bytes of the buffer. + + A long value representing the length of the buffer in bytes. + + + + Provides a base class for mathematical type converters. + + + + + Returns whether this converter can convert an object of the given type to the type of this converter, using the specified context. + + An that provides a format context. + A that represents the type you want to convert from. + + true if this converter can perform the conversion; otherwise, false. + + + + + Returns whether this converter can convert the object to the specified type, using the specified context. + + An that provides a format context. + A that represents the type you want to convert to. + + true if this converter can perform the conversion; otherwise, false. + + + + + Returns whether changing a value on this object requires a call to to create a new value, using the specified context. + + An that provides a format context. + + true if changing a property on this object requires a call to to create a new value; otherwise, false. + + + + + Gets a value indicating whether this object supports properties using the specified context. + + An that provides a format context. + + true because should be called to find the properties of this object. This method never returns false. + + + + + Gets a collection of properties for the type of object specified by the value parameter. + + An that provides a format context. + An that specifies the type of object to get the properties for. + An array of type that will be used as a filter. + + A with the properties that are exposed for the component, or null if there are no properties. + + + + + Gets or sets the collection of exposed properties. + + The collection of exposed properties. + + + + Provides a type converter to convert objects to and from various + other representations. + + + + + Initializes a new instance of the class. + + + + + Returns whether this converter can convert an object of the given type to the type of this converter, using the specified context. + + A that provides a format context. + A System::Type that represents the type you want to convert from. + + true if this converter can perform the conversion; otherwise, false. + + + + Returns whether this converter can convert the object to the specified type, using the specified context. + + A that provides a format context. + A that represents the type you want to convert to. + + true if this converter can perform the conversion; otherwise, false. + + + + Converts the given object to the type of this converter, using the specified context and culture information. + + A that provides a format context. + A . If null is passed, the current culture is assumed. + The to convert. + An that represents the converted value. + + + + Converts the given value object to the specified type, using the specified context and culture information. + + A that provides a format context. + A . If null is passed, the current culture is assumed. + The to convert. + A that represents the type you want to convert to. + An that represents the converted value. + + + + Creates an instance of the type that this is associated with, using the specified context, given a set of property values for the object. + + A that provides a format context. + An of new property values. + An representing the given , or null if the object cannot be created. + + + + Returns whether changing a value on this object requires a call to System::ComponentModel::TypeConverter::CreateInstance(System::Collections::IDictionary^) + to create a new value, using the specified context. + + A that provides a format context. + + false if changing a property on this object requires a call to System::ComponentModel::TypeConverter::CreateInstance(System::Collections::IDictionary^) to create a new value; otherwise, false. + + + + Creates an instance of the type that this is associated with, using the specified context, given a set of property values for the object. + + A that provides a format context. + An that specifies the type of array for which to get properties. + An array of type that is used as a filter. + A with the properties that are exposed for this data type, or a null reference (Nothing in Visual Basic) if there are no properties. + + + + Returns whether this object supports properties, using the specified context. + + A that provides a format context. + + true if GetProperties should be called to find the properties of this object; otherwise, false. + + + + Provides a type converter to convert objects to and from various + other representations. + + + + + Initializes a new instance of the class. + + + + + Returns whether this converter can convert an object of the given type to the type of this converter, using the specified context. + + A that provides a format context. + A System.Type that represents the type you want to convert from. + + true if this converter can perform the conversion; otherwise, false. + + + + Returns whether this converter can convert the object to the specified type, using the specified context. + + A that provides a format context. + A that represents the type you want to convert to. + + true if this converter can perform the conversion; otherwise, false. + + + + Converts the given object to the type of this converter, using the specified context and culture information. + + A that provides a format context. + A . If null is passed, the current culture is assumed. + The to convert. + An that represents the converted value. + + + + Converts the given value object to the specified type, using the specified context and culture information. + + A that provides a format context. + A . If null is passed, the current culture is assumed. + The to convert. + A that represents the type you want to convert to. + An that represents the converted value. + + + + Creates an instance of the type that this is associated with, using the specified context, given a set of property values for the object. + + A that provides a format context. + An of new property values. + An representing the given , or null if the object cannot be created. + + + + Returns whether changing a value on this object requires a call to System::ComponentModel::TypeConverter::CreateInstance(System::Collections::IDictionary^) + to create a new value, using the specified context. + + A that provides a format context. + + false if changing a property on this object requires a call to System.ComponentModel::TypeConverter::CreateInstance(System::Collections::IDictionary^) to create a new value; otherwise, false. + + + + Creates an instance of the type that this is associated with, using the specified context, given a set of property values for the object. + + A that provides a format context. + An that specifies the type of array for which to get properties. + An array of type that is used as a filter. + A with the properties that are exposed for this data type, or a null reference (Nothing in Visual Basic) if there are no properties. + + + + Returns whether this object supports properties, using the specified context. + + A that provides a format context. + + true if GetProperties should be called to find the properties of this object; otherwise, false. + + + + Provides a type converter to convert objects to and from various + other representations. + + + + + Initializes a new instance of the class. + + + + + Returns whether this converter can convert an object of the given type to the type of this converter, using the specified context. + + A that provides a format context. + A System::Type that represents the type you want to convert from. + + true if this converter can perform the conversion; otherwise, false. + + + + Returns whether this converter can convert the object to the specified type, using the specified context. + + A that provides a format context. + A that represents the type you want to convert to. + + true if this converter can perform the conversion; otherwise, false. + + + + Converts the given object to the type of this converter, using the specified context and culture information. + + A that provides a format context. + A . If null is passed, the current culture is assumed. + The to convert. + An that represents the converted value. + + + + Converts the given value object to the specified type, using the specified context and culture information. + + A that provides a format context. + A . If null is passed, the current culture is assumed. + The to convert. + A that represents the type you want to convert to. + An that represents the converted value. + + + + Creates an instance of the type that this is associated with, using the specified context, given a set of property values for the object. + + A that provides a format context. + An of new property values. + An representing the given , or null if the object cannot be created. + + + + Returns whether changing a value on this object requires a call to System::ComponentModel::TypeConverter::CreateInstance(System::Collections::IDictionary^) + to create a new value, using the specified context. + + A that provides a format context. + + false if changing a property on this object requires a call to System::ComponentModel::TypeConverter::CreateInstance(System::Collections::IDictionary^) + + + + Creates an instance of the type that this is associated with, using the specified context, given a set of property values for the object. + + A that provides a format context. + An that specifies the type of array for which to get properties. + An array of type that is used as a filter. + A with the properties that are exposed for this data type, or a null reference (Nothing in Visual Basic) if there are no properties. + + + + Returns whether this object supports properties, using the specified context. + + A that provides a format context. + + true if GetProperties should be called to find the properties of this object; otherwise, false. + + + + Provides a type converter to convert objects to and from various + other representations. + + + + + Returns whether this converter can convert an object of the given type to the type of this converter, using the specified context. + + A that provides a format context. + A System::Type that represents the type you want to convert from. + + true if this converter can perform the conversion; otherwise, false. + + + + Returns whether this converter can convert the object to the specified type, using the specified context. + + A that provides a format context. + A that represents the type you want to convert to. + + true if this converter can perform the conversion; otherwise, false. + + + + Converts the given object to the type of this converter, using the specified context and culture information. + + A that provides a format context. + A . If null is passed, the current culture is assumed. + The to convert. + An that represents the converted value. + + + + Converts the given value object to the specified type, using the specified context and culture information. + + A that provides a format context. + A . If null is passed, the current culture is assumed. + The to convert. + A that represents the type you want to convert to. + An that represents the converted value. + + + + Defines a type converter for . + + + + + Initializes a new instance of the class. + + + + + Converts the given value object to the specified type, using the specified context and culture information. + + An that provides a format context. + A . If null is passed, the current culture is assumed. + The to convert. + The to convert the parameter to. + + An that represents the converted value. + + + The parameter is null. + + + The conversion cannot be performed. + + + + + Converts the given object to the type of this converter, using the specified context and culture information. + + An that provides a format context. + The to use as the current culture. + The to convert. + + An that represents the converted value. + + + The conversion cannot be performed. + + + + + Creates an instance of the type that this is associated with, using the specified context, given a set of property values for the object. + + An that provides a format context. + An of new property values. + + An representing the given , or null if the object cannot be created. This method always returns null. + + + + + Defines a type converter for . + + + + + Initializes a new instance of the class. + + + + + Converts the given value object to the specified type, using the specified context and culture information. + + An that provides a format context. + A . If null is passed, the current culture is assumed. + The to convert. + The to convert the parameter to. + + An that represents the converted value. + + + The parameter is null. + + + The conversion cannot be performed. + + + + + Converts the given object to the type of this converter, using the specified context and culture information. + + An that provides a format context. + The to use as the current culture. + The to convert. + + An that represents the converted value. + + + The conversion cannot be performed. + + + + + Creates an instance of the type that this is associated with, using the specified context, given a set of property values for the object. + + An that provides a format context. + An of new property values. + + An representing the given , or null if the object cannot be created. This method always returns null. + + + + + Defines a type converter for . + + + + + Initializes a new instance of the class. + + + + + Converts the given value object to the specified type, using the specified context and culture information. + + An that provides a format context. + A . If null is passed, the current culture is assumed. + The to convert. + The to convert the parameter to. + + An that represents the converted value. + + + The parameter is null. + + + The conversion cannot be performed. + + + + + Converts the given object to the type of this converter, using the specified context and culture information. + + An that provides a format context. + The to use as the current culture. + The to convert. + + An that represents the converted value. + + + The conversion cannot be performed. + + + + + Creates an instance of the type that this is associated with, using the specified context, given a set of property values for the object. + + An that provides a format context. + An of new property values. + + An representing the given , or null if the object cannot be created. This method always returns null. + + + + + Defines a type converter for . + + + + + Initializes a new instance of the class. + + + + + Converts the given value object to the specified type, using the specified context and culture information. + + An that provides a format context. + A . If null is passed, the current culture is assumed. + The to convert. + The to convert the parameter to. + + An that represents the converted value. + + + The parameter is null. + + + The conversion cannot be performed. + + + + + Converts the given object to the type of this converter, using the specified context and culture information. + + An that provides a format context. + The to use as the current culture. + The to convert. + + An that represents the converted value. + + + The conversion cannot be performed. + + + + + Creates an instance of the type that this is associated with, using the specified context, given a set of property values for the object. + + An that provides a format context. + An of new property values. + + An representing the given , or null if the object cannot be created. This method always returns null. + + + + + Defines a type converter for . + + + + + Initializes a new instance of the class. + + + + + Converts the given value object to the specified type, using the specified context and culture information. + + An that provides a format context. + A . If null is passed, the current culture is assumed. + The to convert. + The to convert the parameter to. + + An that represents the converted value. + + + The parameter is null. + + + The conversion cannot be performed. + + + + + Converts the given object to the type of this converter, using the specified context and culture information. + + An that provides a format context. + The to use as the current culture. + The to convert. + + An that represents the converted value. + + + The conversion cannot be performed. + + + + + Creates an instance of the type that this is associated with, using the specified context, given a set of property values for the object. + + An that provides a format context. + An of new property values. + + An representing the given , or null if the object cannot be created. This method always returns null. + + + + + Describes the type of angle. + + + + + Specifies an angle measurement in revolutions. + + + + + Specifies an angle measurement in degrees. + + + + + Specifies an angle measurement in radians. + + + + + Specifies an angle measurement in gradians. + + + + + Describes how one bounding volume contains another. + + + + + The two bounding volumes don't intersect at all. + + + + + One bounding volume completely contains another. + + + + + The two bounding volumes overlap. + + + + + Describes the result of an intersection with a plane in three dimensions. + + + + + The object is behind the plane. + + + + + The object is in front of the plane. + + + + + The object is intersecting the plane. + + + + + FunctionCallback + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Driver type options. + + + The driver type is required when calling or . + + D3D_DRIVER_TYPE + + + + The driver type is unknown. + + D3D_DRIVER_TYPE_UNKNOWN + + + + A hardware driver, which implements Direct3D features in hardware. This is the primary driver that you should use in your Direct3D applications because it provides the best performance. A hardware driver uses hardware acceleration (on supported hardware) but can also use software for parts of the pipeline that are not supported in hardware. This driver type is often referred to as a hardware abstraction layer or HAL. + + D3D_DRIVER_TYPE_HARDWARE + + + + A reference driver, which is a software implementation that supports every Direct3D feature. A reference driver is designed for accuracy rather than speed and as a result is slow but accurate. The rasterizer portion of the driver does make use of special CPU instructions whenever it can, but it is not intended for retail applications; use it only for feature testing, demonstration of functionality, debugging, or verifying bugs in other drivers. This driver is installed by the DirectX SDK. This driver may be referred to as a REF driver, a reference driver or a reference rasterizer. + + D3D_DRIVER_TYPE_REFERENCE + + + + A NULL driver, which is a reference driver without render capability. This driver is commonly used for debugging non-rendering API calls, it is not appropriate for retail applications. This driver is installed by the DirectX SDK. + + D3D_DRIVER_TYPE_NULL + + + + A software driver, which is a driver implemented completely in software. The software implementation is not intended for a high-performance application due to its very slow performance. + + D3D_DRIVER_TYPE_SOFTWARE + + + + A WARP driver, which is a high-performance software rasterizer. The rasterizer supports {{feature levels}} 9_1 through level 10.1 with a high performance software implementation. For information about limitations creating a WARP device on certain feature levels, see {{Limitations Creating WARP and Reference Devices}}. For more information about using a WARP driver, see {{Windows Advanced Rasterization Platform (WARP) In-Depth Guide}} + + D3D_DRIVER_TYPE_WARP + + + + Describes the set of features targeted by a Direct3D device. + + + See {{Overview For Each Feature Level}} for an overview of the capabilities of each feature level. For information about limitations creating nonhardware-type devices on certain feature levels, see {{Limitations Creating WARP and Reference Devices}}. + + D3D_FEATURE_LEVEL + + + + Targets features supported by Direct3D 9.1 including shader model 2. + + D3D_FEATURE_LEVEL_9_1 + + + + Targets features supported by Direct3D 9.2 including shader model 2. + + D3D_FEATURE_LEVEL_9_2 + + + + Targets features supported by Direct3D 9.3 including shader shader model 3. + + D3D_FEATURE_LEVEL_9_3 + + + + Targets features supported by Direct3D 10.0 including shader shader model 4. + + D3D_FEATURE_LEVEL_10_0 + + + + Targets features supported by Direct3D 10.1 including shader shader model 4. + + D3D_FEATURE_LEVEL_10_1 + + + + Targets features supported by Direct3D 11.0 including shader shader model 5. + + D3D_FEATURE_LEVEL_11_0 + + + + Values that indicate how the pipeline interprets vertex data that is bound to the input-assembler stage. These primitive topology values determine how the vertex data is rendered on screen. + + + Use the method and a value from D3D_PRIMITIVE_TOPOLOGY to bind a primitive topology to the input-assembler stage. Use the method to retrieve the primitive topology for the input-assembler stage. + + D3D_PRIMITIVE_TOPOLOGY + + + + The IA stage has not been initialized with a primitive topology. The IA stage will not function properly unless a primitive topology is defined. + + D3D_PRIMITIVE_TOPOLOGY_UNDEFINED + + + + Interpret the vertex data as a list of points. + + D3D_PRIMITIVE_TOPOLOGY_POINTLIST + + + + Interpret the vertex data as a list of lines. + + D3D_PRIMITIVE_TOPOLOGY_LINELIST + + + + Interpret the vertex data as a line strip. + + D3D_PRIMITIVE_TOPOLOGY_LINESTRIP + + + + Interpret the vertex data as a list of triangles. + + D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST + + + + Interpret the vertex data as a triangle strip. + + D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP + + + + Interpret the vertex data as a list of lines with adjacency data. + + D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ + + + + Interpret the vertex data as a line strip with adjacency data. + + D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ + + + + Interpret the vertex data as a list of triangles with adjacency data. + + D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ + + + + Interpret the vertex data as a triangle strip with adjacency data. + + D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST + + + + Interpret the vertex data as a patch list. + + D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST + + + + Values that identify the type of resource to be viewed as a shader resource. + + + A D3D_SRV_DIMENSION-typed value is specified in the ViewDimension member of the structure or the Dimension member of the structure. + + D3D_SRV_DIMENSION + + + + The type is unknown. + + D3D_SRV_DIMENSION_UNKNOWN + + + + The resource is a buffer. + + D3D_SRV_DIMENSION_BUFFER + + + + The resource is a 1D texture. + + D3D_SRV_DIMENSION_TEXTURE1D + + + + The resource is an array of 1D textures. + + D3D_SRV_DIMENSION_TEXTURE1DARRAY + + + + The resource is a 2D texture. + + D3D_SRV_DIMENSION_TEXTURE2D + + + + The resource is an array of 2D textures. + + D3D_SRV_DIMENSION_TEXTURE2DARRAY + + + + The resource is a multisampling 2D texture. + + D3D_SRV_DIMENSION_TEXTURE2DMS + + + + The resource is an array of multisampling 2D textures. + + D3D_SRV_DIMENSION_TEXTURE2DMSARRAY + + + + The resource is a 3D texture. + + D3D_SRV_DIMENSION_TEXTURE3D + + + + The resource is a cube texture. + + D3D_SRV_DIMENSION_TEXTURECUBE + + + + The resource is an array of cube textures. + + D3D_SRV_DIMENSION_TEXTURECUBEARRAY + + + + The resource is an extended buffer. + + D3D_SRV_DIMENSION_BUFFEREX + + + + D3DCommon Functions. + + + + + Load DLLs and bind functions + + + + + Creates a buffer. + + + The latest D3dcompiler_nn.dll contains the D3DCreateBlob compiler function. Therefore, you are no longer required to create and use an arbitrary length data buffer by using the {{D3D10CreateBlob}} function that is contained in D3d10.dll. + + Number of bytes in the blob. + The address of a reference to the interface that is used to retrieve the buffer. + Returns one of the following {{Direct3D 10 Return Codes}}. + HRESULT D3DCreateBlob([In] SIZE_T Size,[Out] ID3DBlob** ppBlob) + + + + CommonGuid Functions. + + + + Constant None. + + + + This interface is used to return arbitrary length data. + + ID3D10Blob + + + + Initializes a new instance of the class. + + The native pointer. + + + + Get a reference to the data. + + Returns a reference. + void* ID3D10Blob::GetBufferPointer() + + + + Get the size. + + The size of the data, in bytes. + SIZE_T ID3D10Blob::GetBufferSize() + + + + Get a reference to the data. + + void* ID3D10Blob::GetBufferPointer() + + + + Get the size. + + SIZE_T ID3D10Blob::GetBufferSize() + + + + Defines a shader macro. + + + You can use shader macros in your shaders. The D3D_SHADER_MACRO structure defines a single shader macro as shown in the following example: + D3D_SHADER_MACRO Shader_Macros[1] = { "zero", "0" }; + + The following shader or effect creation functions take an array of shader macros as an input parameter: {{D3D10CompileShader}} {{D3DX10CreateEffectFromFile}} {{D3DX10PreprocessShaderFromFile}} {{D3DX11CreateAsyncShaderPreprocessProcessor}} + + D3D_SHADER_MACRO + + + + The macro name. + + const char* Name + + + + The macro definition. + + const char* Definition + + + + Default Constructor for a ShaderMacro + + + + + + + A half precision (16 bit) floating point value. + + + + + Number of decimal digits of precision. + + + + + Number of bits in the mantissa. + + + + + Maximum decimal exponent. + + + + + Maximum binary exponent. + + + + + Minimum decimal exponent. + + + + + Minimum binary exponent. + + + + + Exponent radix. + + + + + Additional rounding. + + + + + Smallest such that 1.0 + epsilon != 1.0 + + + + + Maximum value of the number. + + + + + Minimum value of the number. + + + + + Initializes a new instance of the structure. + + The floating point value that should be stored in 16 bit format. + + + + Converts an array of half precision values into full precision values. + + The values to be converted. + An array of converted values. + + + + Converts an array of full precision values into half precision values. + + The values to be converted. + An array of converted values. + + + + Performs an explicit conversion from to . + + The value to be converted. + The converted value. + + + + Performs an implicit conversion from to . + + The value to be converted. + The converted value. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + + true if has a different value than ; otherwise, false. + + + + Converts the value of the object to its equivalent string representation. + + The string representation of the value of this instance. + + + + Returns the hash code for this instance. + + A 32-bit signed integer hash code. + + + + Determines whether the specified object instances are considered equal. + + + + + true if is the same instance as or + if both are null references or if value1.Equals(value2) returns true; otherwise, false. + + + + Returns a value that indicates whether the current instance is equal to the specified object. + + Object to make the comparison with. + + true if the current instance is equal to the specified object; false otherwise. + + + + Returns a value that indicates whether the current instance is equal to a specified object. + + Object to make the comparison with. + + true if the current instance is equal to the specified object; false otherwise. + + + + Gets or sets the raw 16 bit value used to back this half-float. + + + + + Defines a two component vector, using half precision floating point coordinates. + + + + + Gets or sets the X component of the vector. + + The X component of the vector. + + + + Gets or sets the Y component of the vector. + + The Y component of the vector. + + + + Initializes a new instance of the structure. + + The X component. + The Y component. + + + + Initializes a new instance of the structure. + + The value to set for both the X and Y components. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + + true if has a different value than ; otherwise, false. + + + + Returns the hash code for this instance. + + A 32-bit signed integer hash code. + + + + Determines whether the specified object instances are considered equal. + + + + + true if is the same instance as or + if both are null references or if value1.Equals(value2) returns true; otherwise, false. + + + + Returns a value that indicates whether the current instance is equal to the specified object. + + Object to make the comparison with. + + true if the current instance is equal to the specified object; false otherwise. + + + + Returns a value that indicates whether the current instance is equal to a specified object. + + Object to make the comparison with. + + true if the current instance is equal to the specified object; false otherwise. + + + + Defines a three component vector, using half precision floating point coordinates. + + + + + Gets or sets the X component of the vector. + + The X component of the vector. + + + + Gets or sets the Y component of the vector. + + The Y component of the vector. + + + + Gets or sets the Z component of the vector. + + The Z component of the vector. + + + + Initializes a new instance of the structure. + + The X component. + The Y component. + The Z component. + + + + Initializes a new instance of the structure. + + The value to set for the X, Y, and Z components. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + + true if has a different value than ; otherwise, false. + + + + Returns the hash code for this instance. + + A 32-bit signed integer hash code. + + + + Determines whether the specified object instances are considered equal. + + + + + true if is the same instance as or + if both are null references or if value1.Equals(value2) returns true; otherwise, false. + + + + Returns a value that indicates whether the current instance is equal to the specified object. + + Object to make the comparison with. + + true if the current instance is equal to the specified object; false otherwise. + + + + Returns a value that indicates whether the current instance is equal to a specified object. + + Object to make the comparison with. + + true if the current instance is equal to the specified object; false otherwise. + + + + Defines a four component vector, using half precision floating point coordinates. + + + + + Gets or sets the X component of the vector. + + The X component of the vector. + + + + Gets or sets the Y component of the vector. + + The Y component of the vector. + + + + Gets or sets the Z component of the vector. + + The Z component of the vector. + + + + Gets or sets the W component of the vector. + + The W component of the vector. + + + + Initializes a new instance of the structure. + + The X component. + The Y component. + The Z component. + The W component. + + + + Initializes a new instance of the structure. + + The value to set for the X, Y, Z, and W components. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + + true if has a different value than ; otherwise, false. + + + + Returns the hash code for this instance. + + A 32-bit signed integer hash code. + + + + Determines whether the specified object instances are considered equal. + + + + + true if is the same instance as or + if both are null references or if value1.Equals(value2) returns true; otherwise, false. + + + + Returns a value that indicates whether the current instance is equal to the specified object. + + Object to make the comparison with. + + true if the current instance is equal to the specified object; false otherwise. + + + + Returns a value that indicates whether the current instance is equal to a specified object. + + Object to make the comparison with. + + true if the current instance is equal to the specified object; false otherwise. + + + + Helper class to perform Half/Float conversion. + Code extract from paper : www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf by Jeroen van der Zijp + + + + + Unpacks the specified h. + + The h. + + + + + Packs the specified f. + + The f. + + + + + Represents a four dimensional mathematical vector. + + + + + The size of the type, in bytes. + + + + + A with all of its components set to zero. + + + + + The X unit (1, 0, 0, 0). + + + + + The Y unit (0, 1, 0, 0). + + + + + The Z unit (0, 0, 1, 0). + + + + + The W unit (0, 0, 0, 1). + + + + + A with all of its components set to one. + + + + + The X component of the vector. + + + + + The Y component of the vector. + + + + + The Z component of the vector. + + + + + The W component of the vector. + + + + + Initializes a new instance of the struct. + + The value that will be assigned to all components. + + + + Initializes a new instance of the struct. + + Initial value for the X component of the vector. + Initial value for the Y component of the vector. + Initial value for the Z component of the vector. + Initial value for the W component of the vector. + + + + Initializes a new instance of the struct. + + The values to assign to the X, Y, Z, and W components of the vector. This must be an array with four elements. + Thrown when is null. + Thrown when contains more or less than four elements. + + + + Creates an array containing the elements of the vector. + + A four-element array containing the components of the vector. + + + + Adds two vectors. + + The first vector to add. + The second vector to add. + When the method completes, contains the sum of the two vectors. + + + + Adds two vectors. + + The first vector to add. + The second vector to add. + The sum of the two vectors. + + + + Subtracts two vectors. + + The first vector to subtract. + The second vector to subtract. + When the method completes, contains the difference of the two vectors. + + + + Subtracts two vectors. + + The first vector to subtract. + The second vector to subtract. + The difference of the two vectors. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + When the method completes, contains the scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Modulates a vector with another by performing component-wise multiplication. + + The first vector to modulate. + The second vector to modulate. + When the method completes, contains the modulated vector. + + + + Modulates a vector with another by performing component-wise multiplication. + + The first vector to modulate. + The second vector to modulate. + The modulated vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + When the method completes, contains the scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Reverses the direction of a given vector. + + The vector to negate. + When the method completes, contains a vector facing in the opposite direction. + + + + Reverses the direction of a given vector. + + The vector to negate. + A vector facing in the opposite direction. + + + + Restricts a value to be within a specified range. + + The value to clamp. + The minimum value. + The maximum value. + When the method completes, contains the clamped value. + + + + Restricts a value to be within a specified range. + + The value to clamp. + The minimum value. + The maximum value. + The clamped value. + + + + Returns a vector containing the smallest components of the specified vectors. + + The first source vector. + The second source vector. + When the method completes, contains an new vector composed of the largest components of the source vectors. + + + + Returns a vector containing the largest components of the specified vectors. + + The first source vector. + The second source vector. + A vector containing the largest components of the source vectors. + + + + Returns a vector containing the smallest components of the specified vectors. + + The first source vector. + The second source vector. + When the method completes, contains an new vector composed of the smallest components of the source vectors. + + + + Returns a vector containing the smallest components of the specified vectors. + + The first source vector. + The second source vector. + A vector containing the smallest components of the source vectors. + + + + Adds two vectors. + + The first vector to add. + The second vector to add. + The sum of the two vectors. + + + + Assert a vector (return it unchanged). + + The vector to assert (unchange). + The asserted (unchanged) vector. + + + + Subtracts two vectors. + + The first vector to subtract. + The second vector to subtract. + The difference of the two vectors. + + + + Reverses the direction of a given vector. + + The vector to negate. + A vector facing in the opposite direction. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + true if has a different value than ; otherwise, false. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Performs an implicit conversion from array to . + + The input. + The result of the conversion. + + + + Performs an implicit conversion from to array. + + The input. + The result of the conversion. + + + + Gets or sets the component at the specified index. + + The value of the X, Y, Z, or W component, depending on the index. + The index of the component to access. Use 0 for the X component, 1 for the Y component, 2 for the Z component, and 3 for the W component. + The value of the component at the specified index. + Thrown when the is out of the range [0, 3]. + + + + The implementation of this class is filled by InteropBuilder post-building-event. + + + + + The value for which all absolute numbers smaller than are considered equal to zero. + + + + + A value specifying the approximation of π which is 180 degrees. + + + + + A value specifying the approximation of 2π which is 360 degrees. + + + + + A value specifying the approximation of π/2 which is 90 degrees. + + + + + A value specifying the approximation of π/4 which is 45 degrees. + + + + + Does something with arrays. + + Most likely the type of elements in the array. + Who knows what this is for. + Probably the length of the array. + An array of who knows what. + + + + Converts revolutions to degrees. + + The value to convert. + The converted value. + + + + Converts revolutions to radians. + + The value to convert. + The converted value. + + + + Converts revolutions to gradians. + + The value to convert. + The converted value. + + + + Converts degrees to revolutions. + + The value to convert. + The converted value. + + + + Converts degrees to radians. + + The value to convert. + The converted value. + + + + Converts radians to revolutions. + + The value to convert. + The converted value. + + + + Converts radians to gradians. + + The value to convert. + The converted value. + + + + Converts gradians to revolutions. + + The value to convert. + The converted value. + + + + Converts gradians to degrees. + + The value to convert. + The converted value. + + + + Converts gradians to radians. + + The value to convert. + The converted value. + + + + Converts radians to degrees. + + The value to convert. + The converted value. + + + + Represents a 4x4 mathematical matrix. + + + + + The size of the type, in bytes. + + + + + A with all of its components set to zero. + + + + + The identity . + + + + + Value at row 1 column 1 of the matrix. + + + + + Value at row 1 column 2 of the matrix. + + + + + Value at row 1 column 3 of the matrix. + + + + + Value at row 1 column 4 of the matrix. + + + + + Value at row 2 column 1 of the matrix. + + + + + Value at row 2 column 2 of the matrix. + + + + + Value at row 2 column 3 of the matrix. + + + + + Value at row 2 column 4 of the matrix. + + + + + Value at row 3 column 1 of the matrix. + + + + + Value at row 3 column 2 of the matrix. + + + + + Value at row 3 column 3 of the matrix. + + + + + Value at row 3 column 4 of the matrix. + + + + + Value at row 4 column 1 of the matrix. + + + + + Value at row 4 column 2 of the matrix. + + + + + Value at row 4 column 3 of the matrix. + + + + + Value at row 4 column 4 of the matrix. + + + + + Initializes a new instance of the struct. + + The value that will be assigned to all components. + + + + Initializes a new instance of the struct. + + The value to assign at row 1 column 1 of the matrix. + The value to assign at row 1 column 2 of the matrix. + The value to assign at row 1 column 3 of the matrix. + The value to assign at row 1 column 4 of the matrix. + The value to assign at row 2 column 1 of the matrix. + The value to assign at row 2 column 2 of the matrix. + The value to assign at row 2 column 3 of the matrix. + The value to assign at row 2 column 4 of the matrix. + The value to assign at row 3 column 1 of the matrix. + The value to assign at row 3 column 2 of the matrix. + The value to assign at row 3 column 3 of the matrix. + The value to assign at row 3 column 4 of the matrix. + The value to assign at row 4 column 1 of the matrix. + The value to assign at row 4 column 2 of the matrix. + The value to assign at row 4 column 3 of the matrix. + The value to assign at row 4 column 4 of the matrix. + + + + Initializes a new instance of the struct. + + The values to assign to the components of the matrix. This must be an array with sixteen elements. + Thrown when is null. + Thrown when contains more or less than sixteen elements. + + + + Calculates the determinant of the matrix. + + The determinant of the matrix. + + + + Inverts the matrix. + + + + + Transposes the matrix. + + + + + Orthogonalizes the specified matrix. + + + Orthogonalization is the process of making all rows orthogonal to each other. This + means that any given row in the matrix will be orthogonal to any other given row in the + matrix. + Because this method uses the modified Gram-Schmidt process, the resulting matrix + tends to be numerically unstable. The numeric stability decreases according to the rows + so that the first row is the most stable and the last row is the least stable. + This operation is performed on the rows of the matrix rather than the columns. + If you wish for this operation to be performed on the columns, first transpose the + input and than transpose the output. + + + + + Orthonormalizes the specified matrix. + + + Orthonormalization is the process of making all rows and columns orthogonal to each + other and making all rows and columns of unit length. This means that any given row will + be orthogonal to any other given row and any given column will be orthogonal to any other + given column. Any given row will not be orthogonal to any given column. Every row and every + column will be of unit length. + Because this method uses the modified Gram-Schmidt process, the resulting matrix + tends to be numerically unstable. The numeric stability decreases according to the rows + so that the first row is the most stable and the last row is the least stable. + This operation is performed on the rows of the matrix rather than the columns. + If you wish for this operation to be performed on the columns, first transpose the + input and than transpose the output. + + + + + Decomposes a matrix into an orthonormalized matrix Q and a right traingular matrix R. + + When the method completes, contains the orthonormalized matrix of the decomposition. + When the method completes, contains the right triangular matrix of the decomposition. + + + + Decomposes a matrix into a lower triangular matrix L and an orthonormalized matrix Q. + + When the method completes, contains the lower triangular matrix of the decomposition. + When the method completes, contains the orthonormalized matrix of the decomposition. + + + + Decomposes a matrix into a scale, rotation, and translation. + + When the method completes, contains the scaling component of the decomposed matrix. + When the method completes, contains the rtoation component of the decomposed matrix. + When the method completes, contains the translation component of the decomposed matrix. + + This method is designed to decompose an SRT transformation matrix only. + + + + + Exchanges two rows in the matrix. + + The first row to exchange. This is an index of the row starting at zero. + The second row to exchange. This is an index of the row starting at zero. + + + + + + + + + + + Creates an array containing the elements of the matrix. + + A sixteen-element array containing the components of the matrix. + + + + Determines the sum of two matrices. + + The first matrix to add. + The second matrix to add. + When the method completes, contains the sum of the two matrices. + + + + Determines the sum of two matrices. + + The first matrix to add. + The second matrix to add. + The sum of the two matrices. + + + + Determines the difference between two matrices. + + The first matrix to subtract. + The second matrix to subtract. + When the method completes, contains the difference between the two matrices. + + + + Determines the difference between two matrices. + + The first matrix to subtract. + The second matrix to subtract. + The difference between the two matrices. + + + + Scales a matrix by the given value. + + The matrix to scale. + The amount by which to scale. + When the method completes, contains the scaled matrix. + + + + Scales a matrix by the given value. + + The matrix to scale. + The amount by which to scale. + The scaled matrix. + + + + Determines the product of two matrices. + + The first matrix to multiply. + The second matrix to multiply. + The product of the two matrices. + + + + Determines the product of two matrices. + + The first matrix to multiply. + The second matrix to multiply. + The product of the two matrices. + + + + Scales a matrix by the given value. + + The matrix to scale. + The amount by which to scale. + When the method completes, contains the scaled matrix. + + + + Scales a matrix by the given value. + + The matrix to scale. + The amount by which to scale. + The scaled matrix. + + + + Determines the quotient of two matrices. + + The first matrix to divide. + The second matrix to divide. + When the method completes, contains the quotient of the two matrices. + + + + Determines the quotient of two matrices. + + The first matrix to divide. + The second matrix to divide. + The quotient of the two matrices. + + + + Performs the exponential operation on a matrix. + + The matrix to perform the operation on. + The exponent to raise the matrix to. + When the method completes, contains the exponential matrix. + Thrown when the is negative. + + + + Performs the exponential operation on a matrix. + + The matrix to perform the operation on. + The exponent to raise the matrix to. + The exponential matrix. + Thrown when the is negative. + + + + Negates a matrix. + + The matrix to be negated. + When the method completes, contains the negated matrix. + + + + Negates a matrix. + + The matrix to be negated. + The negated matrix. + + + + Performs a linear interpolation between two matricies. + + Start matrix. + End matrix. + Value between 0 and 1 indicating the weight of . + When the method completes, contains the linear interpolation of the two matricies. + + This method performs the linear interpolation based on the following formula. + start + (end - start) * amount + Passing a value of 0 will cause to be returned; a value of 1 will cause to be returned. + + + + + Performs a linear interpolation between two matricies. + + Start matrix. + End matrix. + Value between 0 and 1 indicating the weight of . + The linear interpolation of the two matrices. + + This method performs the linear interpolation based on the following formula. + start + (end - start) * amount + Passing a value of 0 will cause to be returned; a value of 1 will cause to be returned. + + + + + Performs a cubic interpolation between two matricies. + + Start matrix. + End matrix. + Value between 0 and 1 indicating the weight of . + When the method completes, contains the cubic interpolation of the two matrices. + + + + Performs a cubic interpolation between two matrices. + + Start matrix. + End matrix. + Value between 0 and 1 indicating the weight of . + The cubic interpolation of the two matrices. + + + + Calculates the transpose of the specified matrix. + + The matrix whose transpose is to be calculated. + When the method completes, contains the transpose of the specified matrix. + + + + Calculates the transpose of the specified matrix. + + The matrix whose transpose is to be calculated. + The transpose of the specified matrix. + + + + Calculates the inverse of the specified matrix. + + The matrix whose inverse is to be calculated. + When the method completes, contains the inverse of the specified matrix. + + + + Calculates the inverse of the specified matrix. + + The matrix whose inverse is to be calculated. + The inverse of the specified matrix. + + + + Orthogonalizes the specified matrix. + + The matrix to orthogonalize. + When the method completes, contains the orthogonalized matrix. + + Orthogonalization is the process of making all rows orthogonal to each other. This + means that any given row in the matrix will be orthogonal to any other given row in the + matrix. + Because this method uses the modified Gram-Schmidt process, the resulting matrix + tends to be numerically unstable. The numeric stability decreases according to the rows + so that the first row is the most stable and the last row is the least stable. + This operation is performed on the rows of the matrix rather than the columns. + If you wish for this operation to be performed on the columns, first transpose the + input and than transpose the output. + + + + + Orthogonalizes the specified matrix. + + The matrix to orthogonalize. + The orthogonalized matrix. + + Orthogonalization is the process of making all rows orthogonal to each other. This + means that any given row in the matrix will be orthogonal to any other given row in the + matrix. + Because this method uses the modified Gram-Schmidt process, the resulting matrix + tends to be numerically unstable. The numeric stability decreases according to the rows + so that the first row is the most stable and the last row is the least stable. + This operation is performed on the rows of the matrix rather than the columns. + If you wish for this operation to be performed on the columns, first transpose the + input and than transpose the output. + + + + + Orthonormalizes the specified matrix. + + The matrix to orthonormalize. + When the method completes, contains the orthonormalized matrix. + + Orthonormalization is the process of making all rows and columns orthogonal to each + other and making all rows and columns of unit length. This means that any given row will + be orthogonal to any other given row and any given column will be orthogonal to any other + given column. Any given row will not be orthogonal to any given column. Every row and every + column will be of unit length. + Because this method uses the modified Gram-Schmidt process, the resulting matrix + tends to be numerically unstable. The numeric stability decreases according to the rows + so that the first row is the most stable and the last row is the least stable. + This operation is performed on the rows of the matrix rather than the columns. + If you wish for this operation to be performed on the columns, first transpose the + input and than transpose the output. + + + + + Orthonormalizes the specified matrix. + + The matrix to orthonormalize. + The orthonormalized matrix. + + Orthonormalization is the process of making all rows and columns orthogonal to each + other and making all rows and columns of unit length. This means that any given row will + be orthogonal to any other given row and any given column will be orthogonal to any other + given column. Any given row will not be orthogonal to any given column. Every row and every + column will be of unit length. + Because this method uses the modified Gram-Schmidt process, the resulting matrix + tends to be numerically unstable. The numeric stability decreases according to the rows + so that the first row is the most stable and the last row is the least stable. + This operation is performed on the rows of the matrix rather than the columns. + If you wish for this operation to be performed on the columns, first transpose the + input and than transpose the output. + + + + + Brings the matrix into upper triangular form using elementry row operations. + + The matrix to put into upper triangular form. + When the method completes, contains the upper triangular matrix. + + If the matrix is not invertable (i.e. its determinant is zero) than the result of this + method may produce Single.Nan and Single.Inf values. When the matrix represents a system + of linear equations, than this often means that either no solution exists or an infinite + number of solutions exist. + + + + + Brings the matrix into upper triangular form using elementry row operations. + + The matrix to put into upper triangular form. + The upper triangular matrix. + + If the matrix is not invertable (i.e. its determinant is zero) than the result of this + method may produce Single.Nan and Single.Inf values. When the matrix represents a system + of linear equations, than this often means that either no solution exists or an infinite + number of solutions exist. + + + + + Brings the matrix into lower triangular form using elementry row operations. + + The matrix to put into lower triangular form. + When the method completes, contains the lower triangular matrix. + + If the matrix is not invertable (i.e. its determinant is zero) than the result of this + method may produce Single.Nan and Single.Inf values. When the matrix represents a system + of linear equations, than this often means that either no solution exists or an infinite + number of solutions exist. + + + + + Brings the matrix into lower triangular form using elementry row operations. + + The matrix to put into lower triangular form. + The lower triangular matrix. + + If the matrix is not invertable (i.e. its determinant is zero) than the result of this + method may produce Single.Nan and Single.Inf values. When the matrix represents a system + of linear equations, than this often means that either no solution exists or an infinite + number of solutions exist. + + + + + Brings the matrix into row echelon form using elementry row operations; + + The matrix to put into row echelon form. + When the method completes, contains the row echelon form of the matrix. + + + + Brings the matrix into row echelon form using elementry row operations; + + The matrix to put into row echelon form. + When the method completes, contains the row echelon form of the matrix. + + + + Brings the matrix into reduced row echelon form using elementry row operations. + + The matrix to put into reduced row echelon form. + The fifth column of the matrix. + When the method completes, contains the resultant matrix after the operation. + When the method completes, contains the resultant fifth column of the matrix. + + The fifth column is often called the agumented part of the matrix. This is because the fifth + column is really just an extension of the matrix so that there is a place to put all of the + non-zero components after the operation is complete. + Often times the resultant matrix will the identity matrix or a matrix similar to the identity + matrix. Sometimes, however, that is not possible and numbers other than zero and one may appear. + This method can be used to solve systems of linear equations. Upon completion of this method, + the will contain the solution for the system. It is up to the user + to analyze both the input and the result to determine if a solution really exists. + + + + + Creates a spherical billboard that rotates around a specified object position. + + The position of the object around which the billboard will rotate. + The position of the camera. + The up vector of the camera. + The forward vector of the camera. + When the method completes, contains the created billboard matrix. + + + + Creates a spherical billboard that rotates around a specified object position. + + The position of the object around which the billboard will rotate. + The position of the camera. + The up vector of the camera. + The forward vector of the camera. + The created billboard matrix. + + + + Creates a left-handed, look-at matrix. + + The position of the viewer's eye. + The camera look-at target. + The camera's up vector. + When the method completes, contains the created look-at matrix. + + + + Creates a left-handed, look-at matrix. + + The position of the viewer's eye. + The camera look-at target. + The camera's up vector. + The created look-at matrix. + + + + Creates a right-handed, look-at matrix. + + The position of the viewer's eye. + The camera look-at target. + The camera's up vector. + When the method completes, contains the created look-at matrix. + + + + Creates a right-handed, look-at matrix. + + The position of the viewer's eye. + The camera look-at target. + The camera's up vector. + The created look-at matrix. + + + + Creates a left-handed, orthographic projection matrix. + + Width of the viewing volume. + Height of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + When the method completes, contains the created projection matrix. + + + + Creates a left-handed, orthographic projection matrix. + + Width of the viewing volume. + Height of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + The created projection matrix. + + + + Creates a right-handed, orthographic projection matrix. + + Width of the viewing volume. + Height of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + When the method completes, contains the created projection matrix. + + + + Creates a right-handed, orthographic projection matrix. + + Width of the viewing volume. + Height of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + The created projection matrix. + + + + Creates a left-handed, customized orthographic projection matrix. + + Minimum x-value of the viewing volume. + Maximum x-value of the viewing volume. + Minimum y-value of the viewing volume. + Maximum y-value of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + When the method completes, contains the created projection matrix. + + + + Creates a left-handed, customized orthographic projection matrix. + + Minimum x-value of the viewing volume. + Maximum x-value of the viewing volume. + Minimum y-value of the viewing volume. + Maximum y-value of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + The created projection matrix. + + + + Creates a right-handed, customized orthographic projection matrix. + + Minimum x-value of the viewing volume. + Maximum x-value of the viewing volume. + Minimum y-value of the viewing volume. + Maximum y-value of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + When the method completes, contains the created projection matrix. + + + + Creates a right-handed, customized orthographic projection matrix. + + Minimum x-value of the viewing volume. + Maximum x-value of the viewing volume. + Minimum y-value of the viewing volume. + Maximum y-value of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + The created projection matrix. + + + + Creates a left-handed, perspective projection matrix. + + Width of the viewing volume. + Height of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + When the method completes, contains the created projection matrix. + + + + Creates a left-handed, perspective projection matrix. + + Width of the viewing volume. + Height of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + The created projection matrix. + + + + Creates a right-handed, perspective projection matrix. + + Width of the viewing volume. + Height of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + When the method completes, contains the created projection matrix. + + + + Creates a right-handed, perspective projection matrix. + + Width of the viewing volume. + Height of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + The created projection matrix. + + + + Creates a left-handed, perspective projection matrix based on a field of view. + + Field of view in the y direction, in radians. + Aspect ratio, defined as view space width divided by height. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + When the method completes, contains the created projection matrix. + + + + Creates a left-handed, perspective projection matrix based on a field of view. + + Field of view in the y direction, in radians. + Aspect ratio, defined as view space width divided by height. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + The created projection matrix. + + + + Creates a right-handed, perspective projection matrix based on a field of view. + + Field of view in the y direction, in radians. + Aspect ratio, defined as view space width divided by height. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + When the method completes, contains the created projection matrix. + + + + Creates a right-handed, perspective projection matrix based on a field of view. + + Field of view in the y direction, in radians. + Aspect ratio, defined as view space width divided by height. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + The created projection matrix. + + + + Creates a left-handed, customized perspective projection matrix. + + Minimum x-value of the viewing volume. + Maximum x-value of the viewing volume. + Minimum y-value of the viewing volume. + Maximum y-value of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + When the method completes, contains the created projection matrix. + + + + Creates a left-handed, customized perspective projection matrix. + + Minimum x-value of the viewing volume. + Maximum x-value of the viewing volume. + Minimum y-value of the viewing volume. + Maximum y-value of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + The created projection matrix. + + + + Creates a right-handed, customized perspective projection matrix. + + Minimum x-value of the viewing volume. + Maximum x-value of the viewing volume. + Minimum y-value of the viewing volume. + Maximum y-value of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + When the method completes, contains the created projection matrix. + + + + Creates a right-handed, customized perspective projection matrix. + + Minimum x-value of the viewing volume. + Maximum x-value of the viewing volume. + Minimum y-value of the viewing volume. + Maximum y-value of the viewing volume. + Minimum z-value of the viewing volume. + Maximum z-value of the viewing volume. + The created projection matrix. + + + + Builds a matrix that can be used to reflect vectors about a plane. + + The plane for which the reflection occurs. This parameter is assumed to be normalized. + When the method completes, contains the reflection matrix. + + + + Builds a matrix that can be used to reflect vectors about a plane. + + The plane for which the reflection occurs. This parameter is assumed to be normalized. + The reflection matrix. + + + + Creates a matrix that flattens geometry into a shadow. + + The light direction. If the W component is 0, the light is directional light; if the + W component is 1, the light is a point light. + The plane onto which to project the geometry as a shadow. This parameter is assumed to be normalized. + When the method completes, contains the shadow matrix. + + + + Creates a matrix that flattens geometry into a shadow. + + The light direction. If the W component is 0, the light is directional light; if the + W component is 1, the light is a point light. + The plane onto which to project the geometry as a shadow. This parameter is assumed to be normalized. + The shadow matrix. + + + + Creates a matrix that scales along the x-axis, y-axis, and y-axis. + + Scaling factor for all three axes. + When the method completes, contains the created scaling matrix. + + + + Creates a matrix that scales along the x-axis, y-axis, and y-axis. + + Scaling factor for all three axes. + The created scaling matrix. + + + + Creates a matrix that scales along the x-axis, y-axis, and y-axis. + + Scaling factor that is applied along the x-axis. + Scaling factor that is applied along the y-axis. + Scaling factor that is applied along the z-axis. + When the method completes, contains the created scaling matrix. + + + + Creates a matrix that scales along the x-axis, y-axis, and y-axis. + + Scaling factor that is applied along the x-axis. + Scaling factor that is applied along the y-axis. + Scaling factor that is applied along the z-axis. + The created scaling matrix. + + + + Creates a matrix that uniformally scales along all three axis. + + The uniform scale that is applied along all axis. + When the method completes, contains the created scaling matrix. + + + + Creates a matrix that uniformally scales along all three axis. + + The uniform scale that is applied along all axis. + The created scaling matrix. + + + + Creates a matrix that rotates around the x-axis. + + Angle of rotation in radians. Angles are measured clockwise when looking along the rotation axis toward the origin. + When the method completes, contains the created rotation matrix. + + + + Creates a matrix that rotates around the x-axis. + + Angle of rotation in radians. Angles are measured clockwise when looking along the rotation axis toward the origin. + The created rotation matrix. + + + + Creates a matrix that rotates around the y-axis. + + Angle of rotation in radians. Angles are measured clockwise when looking along the rotation axis toward the origin. + When the method completes, contains the created rotation matrix. + + + + Creates a matrix that rotates around the y-axis. + + Angle of rotation in radians. Angles are measured clockwise when looking along the rotation axis toward the origin. + The created rotation matrix. + + + + Creates a matrix that rotates around the z-axis. + + Angle of rotation in radians. Angles are measured clockwise when looking along the rotation axis toward the origin. + When the method completes, contains the created rotation matrix. + + + + Creates a matrix that rotates around the z-axis. + + Angle of rotation in radians. Angles are measured clockwise when looking along the rotation axis toward the origin. + The created rotation matrix. + + + + Creates a matrix that rotates around an arbitary axis. + + The axis around which to rotate. This parameter is assumed to be normalized. + Angle of rotation in radians. Angles are measured clockwise when looking along the rotation axis toward the origin. + When the method completes, contains the created rotation matrix. + + + + Creates a matrix that rotates around an arbitary axis. + + The axis around which to rotate. This parameter is assumed to be normalized. + Angle of rotation in radians. Angles are measured clockwise when looking along the rotation axis toward the origin. + The created rotation matrix. + + + + Creates a rotation matrix from a quaternion. + + The quaternion to use to build the matrix. + The created rotation matrix. + + + + Creates a rotation matrix from a quaternion. + + The quaternion to use to build the matrix. + The created rotation matrix. + + + + Creates a rotation matrix with a specified yaw, pitch, and roll. + + Yaw around the y-axis, in radians. + Pitch around the x-axis, in radians. + Roll around the z-axis, in radians. + When the method completes, contains the created rotation matrix. + + + + Creates a rotation matrix with a specified yaw, pitch, and roll. + + Yaw around the y-axis, in radians. + Pitch around the x-axis, in radians. + Roll around the z-axis, in radians. + The created rotation matrix. + + + + Creates a translation matrix using the specified offsets. + + The offset for all three coordinate planes. + When the method completes, contains the created translation matrix. + + + + Creates a translation matrix using the specified offsets. + + The offset for all three coordinate planes. + The created translation matrix. + + + + Creates a translation matrix using the specified offsets. + + X-coordinate offset. + Y-coordinate offset. + Z-coordinate offset. + When the method completes, contains the created translation matrix. + + + + Creates a translation matrix using the specified offsets. + + X-coordinate offset. + Y-coordinate offset. + Z-coordinate offset. + The created translation matrix. + + + + Creates a 3D affine transformation matrix. + + Scaling factor. + The rotation of the transformation. + The translation factor of the transformation. + When the method completes, contains the created affine transformation matrix. + + + + Creates a 3D affine transformation matrix. + + Scaling factor. + The rotation of the transformation. + The translation factor of the transformation. + The created affine transformation matrix. + + + + Creates a 3D affine transformation matrix. + + Scaling factor. + The center of the rotation. + The rotation of the transformation. + The translation factor of the transformation. + When the method completes, contains the created affine transformation matrix. + + + + Creates a 3D affine transformation matrix. + + Scaling factor. + The center of the rotation. + The rotation of the transformation. + The translation factor of the transformation. + The created affine transformation matrix. + + + + Creates a 2D affine transformation matrix. + + Scaling factor. + The rotation of the transformation. + The translation factor of the transformation. + When the method completes, contains the created affine transformation matrix. + + + + Creates a 2D affine transformation matrix. + + Scaling factor. + The rotation of the transformation. + The translation factor of the transformation. + The created affine transformation matrix. + + + + Creates a 2D affine transformation matrix. + + Scaling factor. + The center of the rotation. + The rotation of the transformation. + The translation factor of the transformation. + When the method completes, contains the created affine transformation matrix. + + + + Creates a 2D affine transformation matrix. + + Scaling factor. + The center of the rotation. + The rotation of the transformation. + The translation factor of the transformation. + The created affine transformation matrix. + + + + Creates a transformation matrix. + + Center point of the scaling operation. + Scaling rotation amount. + Scaling factor. + The center of the rotation. + The rotation of the transformation. + The translation factor of the transformation. + When the method completes, contains the created transformation matrix. + + + + Creates a transformation matrix. + + Center point of the scaling operation. + Scaling rotation amount. + Scaling factor. + The center of the rotation. + The rotation of the transformation. + The translation factor of the transformation. + The created transformation matrix. + + + + Creates a 2D transformation matrix. + + Center point of the scaling operation. + Scaling rotation amount. + Scaling factor. + The center of the rotation. + The rotation of the transformation. + The translation factor of the transformation. + When the method completes, contains the created transformation matrix. + + + + Creates a 2D transformation matrix. + + Center point of the scaling operation. + Scaling rotation amount. + Scaling factor. + The center of the rotation. + The rotation of the transformation. + The translation factor of the transformation. + The created transformation matrix. + + + + Adds two matricies. + + The first matrix to add. + The second matrix to add. + The sum of the two matricies. + + + + Assert a matrix (return it unchanged). + + The matrix to assert (unchange). + The asserted (unchanged) matrix. + + + + Subtracts two matricies. + + The first matrix to subtract. + The second matrix to subtract. + The difference between the two matricies. + + + + Negates a matrix. + + The matrix to negate. + The negated matrix. + + + + Scales a matrix by a given value. + + The matrix to scale. + The amount by which to scale. + The scaled matrix. + + + + Scales a matrix by a given value. + + The matrix to scale. + The amount by which to scale. + The scaled matrix. + + + + Multiplies two matricies. + + The first matrix to multiply. + The second matrix to multiply. + The product of the two matricies. + + + + Scales a matrix by a given value. + + The matrix to scale. + The amount by which to scale. + The scaled matrix. + + + + Divides two matricies. + + The first matrix to divide. + The second matrix to divide. + The quotient of the two matricies. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + true if has a different value than ; otherwise, false. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Gets or sets the first row in the matrix; that is M11, M12, M13, and M14. + + + + + Gets or sets the second row in the matrix; that is M21, M22, M23, and M24. + + + + + Gets or sets the third row in the matrix; that is M31, M32, M33, and M34. + + + + + Gets or sets the fourth row in the matrix; that is M41, M42, M43, and M44. + + + + + Gets or sets the first column in the matrix; that is M11, M21, M31, and M41. + + + + + Gets or sets the second column in the matrix; that is M12, M22, M32, and M42. + + + + + Gets or sets the third column in the matrix; that is M13, M23, M33, and M43. + + + + + Gets or sets the fourth column in the matrix; that is M14, M24, M34, and M44. + + + + + Gets or sets the translation of the matrix; that is M41, M42, and M43. + + + + + Gets or sets the scale of the matrix; that is M11, M22, and M33. + + + + + Gets a value indicating whether this instance is an identity matrix. + + + true if this instance is an identity matrix; otherwise, false. + + + + + Gets or sets the component at the specified index. + + The value of the matrix component, depending on the index. + The zero-based index of the component to access. + The value of the component at the specified index. + Thrown when the is out of the range [0, 15]. + + + + Gets or sets the component at the specified index. + + The value of the matrix component, depending on the index. + The row of the matrix to access. + The column of the matrix to access. + The value of the component at the specified index. + Thrown when the or is out of the range [0, 3]. + + + + Represents a Wave file format + + + + format type + + + number of channels + + + sample rate + + + for buffer estimation + + + block size of data + + + number of bits per sample of mono data + + + number of following bytes + + + + Creates a new PCM 44.1Khz stereo 16 bit format + + + + + Creates a new 16 bit wave format with the specified sample + rate and channel count + + Sample Rate + Number of channels + + + + Gets the size of a wave buffer equivalent to the latency in milliseconds. + + The milliseconds. + + + + + Creates a WaveFormat with custom members + + The encoding + Sample Rate + Number of channels + Average Bytes Per Second + Block Align + Bits Per Sample + + + + + Creates an A-law wave format + + Sample Rate + Number of Channels + Wave Format + + + + Creates a Mu-law wave format + + Sample Rate + Number of Channels + Wave Format + + + + Creates a new PCM format with the specified sample rate, bit depth and channels + + + + + Creates a new 32 bit IEEE floating point wave format + + sample rate + number of channels + + + + Helper function to retrieve a WaveFormat structure from a pointer + + WaveFormat structure + + + + + Helper function to marshal WaveFormat to an IntPtr + + WaveFormat + IntPtr to WaveFormat structure (needs to be freed by callee) + + + + Reads a new WaveFormat object from a stream + + A binary reader that wraps the stream + + + + Reports this WaveFormat as a string + + String describing the wave format + + + + Compares with another WaveFormat object + + Object to compare to + True if the objects are the same + + + + Provides a Hashcode for this WaveFormat + + A hashcode + + + + Returns the encoding type used + + + + + Returns the number of channels (1=mono,2=stereo etc) + + + + + Returns the sample rate (samples per second) + + + + + Returns the average number of bytes used per second + + + + + Returns the block alignment + + + + + Returns the number of bits per sample (usually 16 or 32, sometimes 24 or 8) + Can be 0 for some codecs + + + + + Returns the number of extra bytes used by this waveformat. Often 0, + except for compressed formats which store extra data after the WAVEFORMATEX header + + + + format type + + + number of channels + + + sample rate + + + for buffer estimation + + + block size of data + + + number of bits per sample of mono data + + + number of following bytes + + + + Summary description for WaveFormatEncoding. + + + + WAVE_FORMAT_UNKNOWN, Microsoft Corporation + + + WAVE_FORMAT_PCM Microsoft Corporation + + + WAVE_FORMAT_ADPCM Microsoft Corporation + + + WAVE_FORMAT_IEEE_FLOAT Microsoft Corporation + + + WAVE_FORMAT_VSELP Compaq Computer Corp. + + + WAVE_FORMAT_IBM_CVSD IBM Corporation + + + WAVE_FORMAT_ALAW Microsoft Corporation + + + WAVE_FORMAT_MULAW Microsoft Corporation + + + WAVE_FORMAT_DTS Microsoft Corporation + + + WAVE_FORMAT_DRM Microsoft Corporation + + + WAVE_FORMAT_OKI_ADPCM OKI + + + WAVE_FORMAT_DVI_ADPCM Intel Corporation + + + WAVE_FORMAT_IMA_ADPCM Intel Corporation + + + WAVE_FORMAT_MEDIASPACE_ADPCM Videologic + + + WAVE_FORMAT_SIERRA_ADPCM Sierra Semiconductor Corp + + + WAVE_FORMAT_G723_ADPCM Antex Electronics Corporation + + + WAVE_FORMAT_DIGISTD DSP Solutions, Inc. + + + WAVE_FORMAT_DIGIFIX DSP Solutions, Inc. + + + WAVE_FORMAT_DIALOGIC_OKI_ADPCM Dialogic Corporation + + + WAVE_FORMAT_MEDIAVISION_ADPCM Media Vision, Inc. + + + WAVE_FORMAT_CU_CODEC Hewlett-Packard Company + + + WAVE_FORMAT_YAMAHA_ADPCM Yamaha Corporation of America + + + WAVE_FORMAT_SONARC Speech Compression + + + WAVE_FORMAT_DSPGROUP_TRUESPEECH DSP Group, Inc + + + WAVE_FORMAT_ECHOSC1 Echo Speech Corporation + + + WAVE_FORMAT_AUDIOFILE_AF36, Virtual Music, Inc. + + + WAVE_FORMAT_APTX Audio Processing Technology + + + WAVE_FORMAT_AUDIOFILE_AF10, Virtual Music, Inc. + + + WAVE_FORMAT_PROSODY_1612, Aculab plc + + + WAVE_FORMAT_LRC, Merging Technologies S.A. + + + WAVE_FORMAT_DOLBY_AC2, Dolby Laboratories + + + WAVE_FORMAT_GSM610, Microsoft Corporation + + + WAVE_FORMAT_MSNAUDIO, Microsoft Corporation + + + WAVE_FORMAT_ANTEX_ADPCME, Antex Electronics Corporation + + + WAVE_FORMAT_CONTROL_RES_VQLPC, Control Resources Limited + + + WAVE_FORMAT_DIGIREAL, DSP Solutions, Inc. + + + WAVE_FORMAT_DIGIADPCM, DSP Solutions, Inc. + + + WAVE_FORMAT_CONTROL_RES_CR10, Control Resources Limited + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + WAVE_FORMAT_GSM + + + WAVE_FORMAT_G729 + + + WAVE_FORMAT_G723 + + + WAVE_FORMAT_ACELP + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + WAVE_FORMAT_WMAUDIO2, Microsoft Corporation + + + + + WAVE_FORMAT_WMAUDIO3, Microsoft Corporation + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + WAVE_FORMAT_EXTENSIBLE + + + + + + WAVE_FORMAT_VORBIS1 "Og" Original stream compatible + + + WAVE_FORMAT_VORBIS2 "Pg" Have independent header + + + WAVE_FORMAT_VORBIS3 "Qg" Have no codebook header + + + WAVE_FORMAT_VORBIS1P "og" Original stream compatible + + + WAVE_FORMAT_VORBIS2P "pg" Have independent headere + + + WAVE_FORMAT_VORBIS3P "qg" Have no codebook header + + + + WaveFormatExtensible + http://www.microsoft.com/whdc/device/audio/multichaud.mspx + + + + + Parameterless constructor for marshalling + + + + + Creates a new WaveFormatExtensible for PCM or IEEE + + + + + String representation + + + + + Internal class to interact with Native Message + + + + + Represents a plane in three dimensional space. + + + + + The normal vector of the plane. + + + + + The distance of the plane along its normal from the origin. + + + + + Initializes a new instance of the struct. + + The value that will be assigned to all components. + + + + Initializes a new instance of the struct. + + The X component of the normal. + The Y component of the normal. + The Z component of the normal. + The distance of the plane along its normal from the origin. + + + + Initializes a new instance of the class. + + Any point that lies along the plane. + The normal vector to the plane. + + + + Initializes a new instance of the struct. + + The normal of the plane. + The distance of the plane along its normal from the origin + + + + Initializes a new instance of the struct. + + First point of a triangle defining the plane. + Second point of a triangle defining the plane. + Third point of a triangle defining the plane. + + + + Initializes a new instance of the struct. + + The values to assign to the A, B, C, and D components of the plane. This must be an array with four elements. + Thrown when is null. + Thrown when contains more or less than four elements. + + + + Changes the coefficients of the normal vector of the plane to make it of unit length. + + + + + Creates an array containing the elements of the plane. + + A four-element array containing the components of the plane. + + + + Determines if there is an intersection between the current object and a point. + + The point to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The ray to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The ray to test. + When the method completes, contains the distance of the intersection, + or 0 if there was no intersection. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The ray to test. + When the method completes, contains the point of intersection, + or if there was no intersection. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The plane to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The plane to test. + When the method completes, contains the line of intersection + as a , or a zero ray if there was no intersection. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a triangle. + + The first vertex of the triangle to test. + The second vertex of the triagnle to test. + The third vertex of the triangle to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The box to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The sphere to test. + Whether the two objects intersected. + + + + Scales the plane by the given scaling factor. + + The plane to scale. + The amount by which to scale the plane. + When the method completes, contains the scaled plane. + + + + Scales the plane by the given scaling factor. + + The plane to scale. + The amount by which to scale the plane. + The scaled plane. + + + + Calculates the dot product of the specified vector and plane. + + The source plane. + The source vector. + When the method completes, contains the dot product of the specified plane and vector. + + + + Calculates the dot product of the specified vector and plane. + + The source plane. + The source vector. + The dot product of the specified plane and vector. + + + + Calculates the dot product of a specified vector and the normal of the plane plus the distance value of the plane. + + The source plane. + The source vector. + When the method completes, contains the dot product of a specified vector and the normal of the Plane plus the distance value of the plane. + + + + Calculates the dot product of a specified vector and the normal of the plane plus the distance value of the plane. + + The source plane. + The source vector. + The dot product of a specified vector and the normal of the Plane plus the distance value of the plane. + + + + Calculates the dot product of the specified vector and the normal of the plane. + + The source plane. + The source vector. + When the method completes, contains the dot product of the specified vector and the normal of the plane. + + + + Calculates the dot product of the specified vector and the normal of the plane. + + The source plane. + The source vector. + The dot product of the specified vector and the normal of the plane. + + + + Changes the coefficients of the normal vector of the plane to make it of unit length. + + The source plane. + When the method completes, contains the normalized plane. + + + + Changes the coefficients of the normal vector of the plane to make it of unit length. + + The source plane. + The normalized plane. + + + + Transforms a normalized plane by a quaternion rotation. + + The normalized source plane. + The quaternion rotation. + When the method completes, contains the transformed plane. + + + + Transforms a normalized plane by a quaternion rotation. + + The normalized source plane. + The quaternion rotation. + The transformed plane. + + + + Transforms an array of normalized planes by a quaternion rotation. + + The array of normalized planes to transform. + The quaternion rotation. + Thrown when is null. + + + + Transforms a normalized plane by a matrix. + + The normalized source plane. + The transformation matrix. + When the method completes, contains the transformed plane. + + + + Transforms a normalized plane by a matrix. + + The normalized source plane. + The transformation matrix. + When the method completes, contains the transformed plane. + + + + Transforms an array of normalized planes by a matrix. + + The array of normalized planes to transform. + The transformation matrix. + Thrown when is null. + + + + Scales a plane by the given value. + + The amount by which to scale the plane. + The plane to scale. + The scaled plane. + + + + Scales a plane by the given value. + + The plane to scale. + The amount by which to scale the plane. + The scaled plane. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + true if has a different value than ; otherwise, false. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Gets or sets the component at the specified index. + + The value of the A, B, C, or D component, depending on the index. + The index of the component to access. Use 0 for the A component, 1 for the B component, 2 for the C component, and 3 for the D component. + The value of the component at the specified index. + Thrown when the is out of the range [0, 3]. + + + + Represents a four dimensional mathematical quaternion. + + + + + The size of the type, in bytes. + + + + + A with all of its components set to zero. + + + + + A with all of its components set to one. + + + + + The identity (0, 0, 0, 1). + + + + + The X component of the quaternion. + + + + + The Y component of the quaternion. + + + + + The Z component of the quaternion. + + + + + The W component of the quaternion. + + + + + Initializes a new instance of the struct. + + The value that will be assigned to all components. + + + + Initializes a new instance of the struct. + + A vector containing the values with which to initialize the components. + + + + Initializes a new instance of the struct. + + A vector containing the values with which to initialize the X, Y, and Z components. + Initial value for the W component of the quaternion. + + + + Initializes a new instance of the struct. + + A vector containing the values with which to initialize the X and Y components. + Initial value for the Z component of the quaternion. + Initial value for the W component of the quaternion. + + + + Initializes a new instance of the struct. + + Initial value for the X component of the quaternion. + Initial value for the Y component of the quaternion. + Initial value for the Z component of the quaternion. + Initial value for the W component of the quaternion. + + + + Initializes a new instance of the struct. + + The values to assign to the X, Y, Z, and W components of the quaternion. This must be an array with four elements. + Thrown when is null. + Thrown when contains more or less than four elements. + + + + Conjugates the quaternion. + + + + + Conjugates and renormalizes the quaternion. + + + + + Calculates the length of the quaternion. + + The length of the quaternion. + + may be preferred when only the relative length is needed + and speed is of the essence. + + + + + Calculates the squared length of the quaternion. + + The squared length of the quaternion. + + This method may be preferred to when only a relative length is needed + and speed is of the essence. + + + + + Converts the quaternion into a unit quaternion. + + + + + Creates an array containing the elements of the quaternion. + + A four-element array containing the components of the quaternion. + + + + Adds two quaternions. + + The first quaternion to add. + The second quaternion to add. + When the method completes, contains the sum of the two quaternions. + + + + Adds two quaternions. + + The first quaternion to add. + The second quaternion to add. + The sum of the two quaternions. + + + + Subtracts two quaternions. + + The first quaternion to subtract. + The second quaternion to subtract. + When the method completes, contains the difference of the two quaternions. + + + + Subtracts two quaternions. + + The first quaternion to subtract. + The second quaternion to subtract. + The difference of the two quaternions. + + + + Scales a quaternion by the given value. + + The quaternion to scale. + The amount by which to scale the quaternion. + When the method completes, contains the scaled quaternion. + + + + Scales a quaternion by the given value. + + The quaternion to scale. + The amount by which to scale the quaternion. + The scaled quaternion. + + + + Modulates a quaternion by another. + + The first quaternion to modulate. + The second quaternion to modulate. + When the moethod completes, contains the modulated quaternion. + + + + Modulates a quaternion by another. + + The first quaternion to modulate. + The second quaternion to modulate. + The modulated quaternion. + + + + Reverses the direction of a given quaternion. + + The quaternion to negate. + When the method completes, contains a quaternion facing in the opposite direction. + + + + Reverses the direction of a given quaternion. + + The quaternion to negate. + A quaternion facing in the opposite direction. + + + + Returns a containing the 4D Cartesian coordinates of a point specified in Barycentric coordinates relative to a 2D triangle. + + A containing the 4D Cartesian coordinates of vertex 1 of the triangle. + A containing the 4D Cartesian coordinates of vertex 2 of the triangle. + A containing the 4D Cartesian coordinates of vertex 3 of the triangle. + Barycentric coordinate b2, which expresses the weighting factor toward vertex 2 (specified in ). + Barycentric coordinate b3, which expresses the weighting factor toward vertex 3 (specified in ). + When the method completes, contains a new containing the 4D Cartesian coordinates of the specified point. + + + + Returns a containing the 4D Cartesian coordinates of a point specified in Barycentric coordinates relative to a 2D triangle. + + A containing the 4D Cartesian coordinates of vertex 1 of the triangle. + A containing the 4D Cartesian coordinates of vertex 2 of the triangle. + A containing the 4D Cartesian coordinates of vertex 3 of the triangle. + Barycentric coordinate b2, which expresses the weighting factor toward vertex 2 (specified in ). + Barycentric coordinate b3, which expresses the weighting factor toward vertex 3 (specified in ). + A new containing the 4D Cartesian coordinates of the specified point. + + + + Conjugates a quaternion. + + The quaternion to conjugate. + When the method completes, contains the conjugated quaternion. + + + + Conjugates a quaternion. + + The quaternion to conjugate. + The conjugated quaternion. + + + + Calculates the dot product of two quaternions. + + First source quaternion. + Second source quaternion. + When the method completes, contains the dot product of the two quaternions. + + + + Calculates the dot product of two quaternions. + + First source quaternion. + Second source quaternion. + The dot product of the two quaternions. + + + + Exponentiates a quaternion. + + The quaternion to exponentiate. + When the method completes, contains the exponentiated quaternion. + + + + Exponentiates a quaternion. + + The quaternion to exponentiate. + The exponentiated quaternion. + + + + Conjugates and renormalizes the quaternion. + + The quaternion to conjugate and renormalize. + When the method completes, contains the conjugated and renormalized quaternion. + + + + Conjugates and renormalizes the quaternion. + + The quaternion to conjugate and renormalize. + The conjugated and renormalized quaternion. + + + + Performs a linear interpolation between two quaternions. + + Start quaternion. + End quaternion. + Value between 0 and 1 indicating the weight of . + When the method completes, contains the linear interpolation of the two quaternions. + + This method performs the linear interpolation based on the following formula. + start + (end - start) * amount + Passing a value of 0 will cause to be returned; a value of 1 will cause to be returned. + + + + + Performs a linear interpolation between two quaternion. + + Start quaternion. + End quaternion. + Value between 0 and 1 indicating the weight of . + The linear interpolation of the two quaternions. + + This method performs the linear interpolation based on the following formula. + start + (end - start) * amount + Passing a value of 0 will cause to be returned; a value of 1 will cause to be returned. + + + + + Calculates the natural logarithm of the specified quaternion. + + The quaternion whose logarithm will be calculated. + When the method completes, contains the natural logarithm of the quaternion. + + + + Calculates the natural logarithm of the specified quaternion. + + The quaternion whose logarithm will be calculated. + The natural logarithm of the quaternion. + + + + Converts the quaternion into a unit quaternion. + + The quaternion to normalize. + When the method completes, contains the normalized quaternion. + + + + Converts the quaternion into a unit quaternion. + + The quaternion to normalize. + The normalized quaternion. + + + + Creates a quaternion given a rotation and an axis. + + The axis of rotation. + The angle of rotation. + When the method completes, contains the newly created quaternion. + + + + Creates a quaternion given a rotation and an axis. + + The axis of rotation. + The angle of rotation. + The newly created quaternion. + + + + Creates a quaternion given a rotation matrix. + + The rotation matrix. + When the method completes, contains the newly created quaternion. + + + + Creates a quaternion given a rotation matrix. + + The rotation matrix. + The newly created quaternion. + + + + Creates a quaternion given a yaw, pitch, and roll value. + + The yaw of rotation. + The pitch of rotation. + The roll of rotation. + When the method completes, contains the newly created quaternion. + + + + Creates a quaternion given a yaw, pitch, and roll value. + + The yaw of rotation. + The pitch of rotation. + The roll of rotation. + The newly created quaternion. + + + + Interpolates between two quaternions, using spherical linear interpolation. + + Start quaternion. + End quaternion. + Value between 0 and 1 indicating the weight of . + When the method completes, contains the spherical linear interpolation of the two quaternions. + + + + Interpolates between two quaternions, using spherical linear interpolation. + + Start quaternion. + End quaternion. + Value between 0 and 1 indicating the weight of . + The spherical linear interpolation of the two quaternions. + + + + Interpolates between quaternions, using spherical quadrangle interpolation. + + First source quaternion. + Second source quaternion. + Thrid source quaternion. + Fourth source quaternion. + Value between 0 and 1 indicating the weight of interpolation. + When the method completes, contains the spherical quadrangle interpolation of the quaternions. + + + + Interpolates between quaternions, using spherical quadrangle interpolation. + + First source quaternion. + Second source quaternion. + Thrid source quaternion. + Fourth source quaternion. + Value between 0 and 1 indicating the weight of interpolation. + The spherical quadrangle interpolation of the quaternions. + + + + Sets up control points for spherical quadrangle interpolation. + + First source quaternion. + Second source quaternion. + Third source quaternion. + Fourth source quaternion. + An array of three quaternions that represent control points for spherical quadrangle interpolation. + + + + Adds two quaternions. + + The first quaternion to add. + The second quaternion to add. + The sum of the two quaternions. + + + + Subtracts two quaternions. + + The first quaternion to subtract. + The second quaternion to subtract. + The difference of the two quaternions. + + + + Reverses the direction of a given quaternion. + + The quaternion to negate. + A quaternion facing in the opposite direction. + + + + Scales a quaternion by the given value. + + The quaternion to scale. + The amount by which to scale the quaternion. + The scaled quaternion. + + + + Scales a quaternion by the given value. + + The quaternion to scale. + The amount by which to scale the quaternion. + The scaled quaternion. + + + + Multiplies a quaternion by another. + + The first quaternion to multiply. + The second quaternion to multiply. + The multiplied quaternion. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + true if has a different value than ; otherwise, false. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Gets a value indicating whether this instance is equivalent to the identity quaternion. + + + true if this instance is an identity quaternion; otherwise, false. + + + + + Gets a value indicting whether this instance is normalized. + + + + + Gets the angle of the quaternion. + + The quaternion's angle. + + + + Gets the axis components of the quaternion. + + The axis components of the quaternion. + + + + Gets or sets the component at the specified index. + + The value of the X, Y, Z, or W component, depending on the index. + The index of the component to access. Use 0 for the X component, 1 for the Y component, 2 for the Z component, and 3 for the W component. + The value of the component at the specified index. + Thrown when the is out of the range [0, 3]. + + + + Represents a three dimensional line based on a point in space and a direction. + + + + + The position in three dimensional space where the ray starts. + + + + + The normalized direction in which the ray points. + + + + + Initializes a new instance of the struct. + + The position in three dimensional space of the origin of the ray. + The normalized direction of the ray. + + + + Determines if there is an intersection between the current object and a point. + + The point to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The ray to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The ray to test. + When the method completes, contains the point of intersection, + or if there was no intersection. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The plane to test + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The plane to test. + When the method completes, contains the distance of the intersection, + or 0 if there was no intersection. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The plane to test. + When the method completes, contains the point of intersection, + or if there was no intersection. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a triangle. + + The first vertex of the triangle to test. + The second vertex of the triangle to test. + The third vertex of the triangle to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a triangle. + + The first vertex of the triangle to test. + The second vertex of the triangle to test. + The third vertex of the triangle to test. + When the method completes, contains the distance of the intersection, + or 0 if there was no intersection. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a triangle. + + The first vertex of the triangle to test. + The second vertex of the triangle to test. + The third vertex of the triangle to test. + When the method completes, contains the point of intersection, + or if there was no intersection. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The box to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The box to test. + When the method completes, contains the distance of the intersection, + or 0 if there was no intersection. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The box to test. + When the method completes, contains the point of intersection, + or if there was no intersection. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The sphere to test. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The sphere to test. + When the method completes, contains the distance of the intersection, + or 0 if there was no intersection. + Whether the two objects intersected. + + + + Determines if there is an intersection between the current object and a . + + The sphere to test. + When the method completes, contains the point of intersection, + or if there was no intersection. + Whether the two objects intersected. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + true if has a different value than ; otherwise, false. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Define a Rectangle. This structure is slightly different from System.Drawing.Rectangle as It is + internally storing Left,Top,Right,Bottom instead of Left,Top,Width,Height. + Although automatic casting from a to System.Drawing.Rectangle is provided by this class. + + + + + An empty rectangle + + + + + Initializes a new instance of the struct. + + The left. + The top. + The right. + The bottom. + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Performs an implicit conversion from to . + + The input. + The result of the conversion. + + + + Rectangles the specified input. + + The input. + + + + + Implements the operator ==. + + The left. + The right. + The result of the operator. + + + + Implements the operator !=. + + The left. + The right. + The result of the operator. + + + + Gets or sets the left. + + The left. + + + + Gets or sets the top. + + The top. + + + + Gets or sets the right. + + The right. + + + + Gets or sets the bottom. + + The bottom. + + + + Gets or sets the width. + + The width. + + + + Gets or sets the height. + + The height. + + + + Define a RectangleF. This structure is slightly different from System.Drawing.RectangleF as It is + internally storing Left,Top,Right,Bottom instead of Left,Top,Width,Height. + Although automatic casting from a to System.Drawing.Rectangle is provided by this class. + + + + + An empty rectangle + + + + + Initializes a new instance of the struct. + + The left. + The top. + The right. + The bottom. + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Performs an implicit conversion from to . + + The input. + The result of the conversion. + + + + Rectangles the F. + + The input. + + + + + Implements the operator ==. + + The left. + The right. + The result of the operator. + + + + Implements the operator !=. + + The left. + The right. + The result of the operator. + + + + Gets or sets the left. + + The left. + + + + Gets or sets the top. + + The top. + + + + Gets or sets the right. + + The right. + + + + Gets or sets the bottom. + + The bottom. + + + + Gets or sets the width. + + The width. + + + + Gets or sets the height. + + The height. + + + + Result structure for COM methods. + + + + + Initializes a new instance of the struct. + + The HRESULT error code. + + + + Initializes a new instance of the struct. + + The HRESULT error code. + + + + Performs an implicit conversion from to . + + The result. + The result of the conversion. + + + + Equalses the specified other. + + The other. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Implements the operator ==. + + The left. + The right. + The result of the operator. + + + + Implements the operator !=. + + The left. + The right. + The result of the operator. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Checks the error. + + + + + Result code Ok + + + + + Result code Abord + + + + + Result code AccessDenied + + + + + Result code Fail + + + + + Resuld code Handle + + + + + Result code invalid argument + + + + + Result code no interface + + + + + Result code not implemented + + + + + Result code out of memory + + + + + Result code Invalid pointer + + + + + Unexpected failure + + + + + Gets the HRESULT error code. + + The HRESULT error code. + + + + Gets a value indicating whether this is success. + + true if success; otherwise, false. + + + + Gets a value indicating whether this is failure. + + true if failure; otherwise, false. + + + + The maximum number of bytes to which a pointer can point. Use for a count that must span the full range of a pointer. + Equivalent to Windows type SIZE_T. + + + + + Default constructor. + + value to set + + + + Default constructor. + + value to set + + + + Default constructor. + + value to set + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Adds two sizes. + + The first size to add. + The second size to add. + The sum of the two sizes. + + + + Assert a size (return it unchanged). + + The size to assert (unchange). + The asserted (unchanged) size. + + + + Subtracts two sizes. + + The first size to subtract. + The second size to subtract. + The difference of the two sizes. + + + + Reverses the direction of a given size. + + The size to negate. + A size facing in the opposite direction. + + + + Scales a size by the given value. + + The size to scale. + The amount by which to scale the size. + The scaled size. + + + + Scales a size by the given value. + + The size to scale. + The amount by which to scale the size. + The scaled size. + + + + Scales a size by the given value. + + The size to scale. + The amount by which to scale the size. + The scaled size. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + true if has a different value than ; otherwise, false. + + + + Performs an implicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an implicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an implicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an implicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an implicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an implicit conversion from void* to . + + The value. + The result of the conversion. + + + + Performs an implicit conversion from to void*. + + The value. + The result of the conversion. + + + + The base class for errors that occur in SharpDX. + + None + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The result code that caused this exception. + + + + Initializes a new instance of the class. + + The message describing the exception. + formatting arguments + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + Initializes a new instance of the class. + + The message describing the exception. + The exception that caused this exception. + formatting arguments + + + + When overridden in a derived class, sets the with information about the exception. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + + + + Gets the Result code for the exception. This value indicates + the specific type of failure that occured within SharpDX. + + + + + Utility class. + + + + + Force an ini + + + + + Native memcpy. + + The destination memory location + The source memory location. + The count. + + + + + Native memcpy. + + The destination memory location + The source memory location. + The count. + + + + + Return the sizeof a struct from a CLR. Equivalent to sizeof operator but works on generics too. + + a struct to evaluate + sizeof this struct + + + + Reads the specified T data from a memory location. + + Type of a data to read + Memory location to read from. + The data write to. + source pointer + sizeof(T) + + + + Reads the specified array T[] data from a memory location. + + Type of a data to read + Memory location to read from. + The data write to. + The offset in the array to write to. + The number of T element to read from the memory location + source pointer + sizeof(T) * count + + + + Writes the specified T data to a memory location. + + Type of a data to write + Memory location to write to. + The data to write. + destination pointer + sizeof(T) + + + + Writes the specified array T[] data to a memory location. + + Type of a data to write + Memory location to write to. + The array of T data to write. + The offset in the array to read from. + The number of T element to write to the memory location + destination pointer + sizeof(T) * count + + + + Converts to int array. + + The array. + + + + + Converts to bool array. + + The array. + + + + + Gets the IUnknown from object. Similar to but accept null object + by returning an IntPtr.Zero IUnknown pointer. + + The managed object. + an IUnknown pointer to a managed object + + + + Gets an object from an IUnknown pointer. Similar to but accept IntPtr.Zero + by returning a null object. + + an IUnknown pointer to a managed object + The managed object. + + + + Read stream to a byte[] buffer + + input stream + a byte[] buffer + + + + Read stream to a byte[] buffer + + input stream + length to read + a byte[] buffer + + + + Loads a native library. + + Name of the DLL. + If dll was not found + + + + + Gets the proc address of a dll. + + The handle. + The DLL function to import. + If the function was not found + + + + + Represents a two dimensional mathematical vector. + + + + + The size of the type, in bytes. + + + + + A with all of its components set to zero. + + + + + The X unit (1, 0). + + + + + The Y unit (0, 1). + + + + + A with all of its components set to one. + + + + + The X component of the vector. + + + + + The Y component of the vector. + + + + + Initializes a new instance of the struct. + + The value that will be assigned to all components. + + + + Initializes a new instance of the struct. + + Initial value for the X component of the vector. + Initial value for the Y component of the vector. + + + + Initializes a new instance of the struct. + + The values to assign to the X and Y components of the vector. This must be an array with two elements. + Thrown when is null. + Thrown when contains more or less than two elements. + + + + Calculates the length of the vector. + + The length of the vector. + + may be preferred when only the relative length is needed + and speed is of the essence. + + + + + Calculates the squared length of the vector. + + The squared length of the vector. + + This method may be preferred to when only a relative length is needed + and speed is of the essence. + + + + + Converts the vector into a unit vector. + + + + + Creates an array containing the elements of the vector. + + A two-element array containing the components of the vector. + + + + Adds two vectors. + + The first vector to add. + The second vector to add. + When the method completes, contains the sum of the two vectors. + + + + Adds two vectors. + + The first vector to add. + The second vector to add. + The sum of the two vectors. + + + + Subtracts two vectors. + + The first vector to subtract. + The second vector to subtract. + When the method completes, contains the difference of the two vectors. + + + + Subtracts two vectors. + + The first vector to subtract. + The second vector to subtract. + The difference of the two vectors. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + When the method completes, contains the scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Modulates a vector with another by performing component-wise multiplication. + + The first vector to modulate. + The second vector to modulate. + When the method completes, contains the modulated vector. + + + + Modulates a vector with another by performing component-wise multiplication. + + The first vector to modulate. + The second vector to modulate. + The modulated vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + When the method completes, contains the scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Reverses the direction of a given vector. + + The vector to negate. + When the method completes, contains a vector facing in the opposite direction. + + + + Reverses the direction of a given vector. + + The vector to negate. + A vector facing in the opposite direction. + + + + Returns a containing the 2D Cartesian coordinates of a point specified in Barycentric coordinates relative to a 2D triangle. + + A containing the 2D Cartesian coordinates of vertex 1 of the triangle. + A containing the 2D Cartesian coordinates of vertex 2 of the triangle. + A containing the 2D Cartesian coordinates of vertex 3 of the triangle. + Barycentric coordinate b2, which expresses the weighting factor toward vertex 2 (specified in ). + Barycentric coordinate b3, which expresses the weighting factor toward vertex 3 (specified in ). + When the method completes, contains the 2D Cartesian coordinates of the specified point. + + + + Returns a containing the 2D Cartesian coordinates of a point specified in Barycentric coordinates relative to a 2D triangle. + + A containing the 2D Cartesian coordinates of vertex 1 of the triangle. + A containing the 2D Cartesian coordinates of vertex 2 of the triangle. + A containing the 2D Cartesian coordinates of vertex 3 of the triangle. + Barycentric coordinate b2, which expresses the weighting factor toward vertex 2 (specified in ). + Barycentric coordinate b3, which expresses the weighting factor toward vertex 3 (specified in ). + A new containing the 2D Cartesian coordinates of the specified point. + + + + Restricts a value to be within a specified range. + + The value to clamp. + The minimum value. + The maximum value. + When the method completes, contains the clamped value. + + + + Restricts a value to be within a specified range. + + The value to clamp. + The minimum value. + The maximum value. + The clamped value. + + + + Calculates the distance between two vectors. + + The first vector. + The second vector. + When the method completes, contains the distance between the two vectors. + + may be preferred when only the relative distance is needed + and speed is of the essence. + + + + + Calculates the distance between two vectors. + + The first vector. + The second vector. + The distance between the two vectors. + + may be preferred when only the relative distance is needed + and speed is of the essence. + + + + + Calculates the squared distance between two vectors. + + The first vector. + The second vector + When the method completes, contains the squared distance between the two vectors. + Distance squared is the value before taking the square root. + Distance squared can often be used in place of distance if relative comparisons are being made. + For example, consider three points A, B, and C. To determine whether B or C is further from A, + compare the distance between A and B to the distance between A and C. Calculating the two distances + involves two square roots, which are computationally expensive. However, using distance squared + provides the same information and avoids calculating two square roots. + + + + + Calculates the squared distance between two vectors. + + The first vector. + The second vector. + The squared distance between the two vectors. + Distance squared is the value before taking the square root. + Distance squared can often be used in place of distance if relative comparisons are being made. + For example, consider three points A, B, and C. To determine whether B or C is further from A, + compare the distance between A and B to the distance between A and C. Calculating the two distances + involves two square roots, which are computationally expensive. However, using distance squared + provides the same information and avoids calculating two square roots. + + + + + Calculates the dot product of two vectors. + + First source vector. + Second source vector. + When the method completes, contains the dot product of the two vectors. + + + + Calculates the dot product of two vectors. + + First source vector. + Second source vector. + The dot product of the two vectors. + + + + Converts the vector into a unit vector. + + The vector to normalize. + When the method completes, contains the normalized vector. + + + + Converts the vector into a unit vector. + + The vector to normalize. + The normalized vector. + + + + Performs a linear interpolation between two vectors. + + Start vector. + End vector. + Value between 0 and 1 indicating the weight of . + When the method completes, contains the linear interpolation of the two vectors. + + This method performs the linear interpolation based on the following formula. + start + (end - start) * amount + Passing a value of 0 will cause to be returned; a value of 1 will cause to be returned. + + + + + Performs a linear interpolation between two vectors. + + Start vector. + End vector. + Value between 0 and 1 indicating the weight of . + The linear interpolation of the two vectors. + + This method performs the linear interpolation based on the following formula. + start + (end - start) * amount + Passing a value of 0 will cause to be returned; a value of 1 will cause to be returned. + + + + + Performs a cubic interpolation between two vectors. + + Start vector. + End vector. + Value between 0 and 1 indicating the weight of . + When the method completes, contains the cubic interpolation of the two vectors. + + + + Performs a cubic interpolation between two vectors. + + Start vector. + End vector. + Value between 0 and 1 indicating the weight of . + The cubic interpolation of the two vectors. + + + + Performs a Hermite spline interpolation. + + First source position vector. + First source tangent vector. + Second source position vector. + Second source tangent vector. + Weighting factor. + When the method completes, contains the result of the Hermite spline interpolation. + + + + Performs a Hermite spline interpolation. + + First source position vector. + First source tangent vector. + Second source position vector. + Second source tangent vector. + Weighting factor. + The result of the Hermite spline interpolation. + + + + Performs a Catmull-Rom interpolation using the specified positions. + + The first position in the interpolation. + The second position in the interpolation. + The third position in the interpolation. + The fourth position in the interpolation. + Weighting factor. + When the method completes, contains the result of the Catmull-Rom interpolation. + + + + Performs a Catmull-Rom interpolation using the specified positions. + + The first position in the interpolation. + The second position in the interpolation. + The third position in the interpolation. + The fourth position in the interpolation. + Weighting factor. + A vector that is the result of the Catmull-Rom interpolation. + + + + Returns a vector containing the smallest components of the specified vectors. + + The first source vector. + The second source vector. + When the method completes, contains an new vector composed of the largest components of the source vectors. + + + + Returns a vector containing the largest components of the specified vectors. + + The first source vector. + The second source vector. + A vector containing the largest components of the source vectors. + + + + Returns a vector containing the smallest components of the specified vectors. + + The first source vector. + The second source vector. + When the method completes, contains an new vector composed of the smallest components of the source vectors. + + + + Returns a vector containing the smallest components of the specified vectors. + + The first source vector. + The second source vector. + A vector containing the smallest components of the source vectors. + + + + Returns the reflection of a vector off a surface that has the specified normal. + + The source vector. + Normal of the surface. + When the method completes, contains the reflected vector. + Reflect only gives the direction of a reflection off a surface, it does not determine + whether the original vector was close enough to the surface to hit it. + + + + Returns the reflection of a vector off a surface that has the specified normal. + + The source vector. + Normal of the surface. + The reflected vector. + Reflect only gives the direction of a reflection off a surface, it does not determine + whether the original vector was close enough to the surface to hit it. + + + + Orthogonalizes a list of vectors. + + The list of orthogonalized vectors. + The list of vectors to orthogonalize. + + Orthogonalization is the process of making all vectors orthogonal to each other. This + means that any given vector in the list will be orthogonal to any other given vector in the + list. + Because this method uses the modified Gram-Schmidt process, the resulting vectors + tend to be numerically unstable. The numeric stability decreases according to the vectors + position in the list so that the first vector is the most stable and the last vector is the + least stable. + + Thrown when or is null. + Thrown when is shorter in length than . + + + + Orthonormalizes a list of vectors. + + The list of orthonormalized vectors. + The list of vectors to orthonormalize. + + Orthonormalization is the process of making all vectors orthogonal to each + other and making all vectors of unit length. This means that any given vector will + be orthogonal to any other given vector in the list. + Because this method uses the modified Gram-Schmidt process, the resulting vectors + tend to be numerically unstable. The numeric stability decreases according to the vectors + position in the list so that the first vector is the most stable and the last vector is the + least stable. + + Thrown when or is null. + Thrown when is shorter in length than . + + + + Transforms a 2D vector by the given rotation. + + The vector to rotate. + The rotation to apply. + When the method completes, contains the transformed . + + + + Transforms a 2D vector by the given rotation. + + The vector to rotate. + The rotation to apply. + The transformed . + + + + Transforms an array of vectors by the given rotation. + + The array of vectors to transform. + The rotation to apply. + The array for which the transformed vectors are stored. + This array may be the same array as . + Thrown when or is null. + Thrown when is shorter in length than . + + + + Transforms a 2D vector by the given . + + The source vector. + The transformation . + When the method completes, contains the transformed . + + + + Transforms a 2D vector by the given . + + The source vector. + The transformation . + The transformed . + + + + Transforms an array of 2D vectors by the given . + + The array of vectors to transform. + The transformation . + The array for which the transformed vectors are stored. + Thrown when or is null. + Thrown when is shorter in length than . + + + + Performs a coordinate transformation using the given . + + The coordinate vector to transform. + The transformation . + When the method completes, contains the transformed coordinates. + + A coordinate transform performs the transformation with the assumption that the w component + is one. The four dimensional vector obtained from the transformation operation has each + component in the vector divided by the w component. This forces the wcomponent to be one and + therefore makes the vector homogeneous. The homogeneous vector is often prefered when working + with coordinates as the w component can safely be ignored. + + + + + Performs a coordinate transformation using the given . + + The coordinate vector to transform. + The transformation . + The transformed coordinates. + + A coordinate transform performs the transformation with the assumption that the w component + is one. The four dimensional vector obtained from the transformation operation has each + component in the vector divided by the w component. This forces the wcomponent to be one and + therefore makes the vector homogeneous. The homogeneous vector is often prefered when working + with coordinates as the w component can safely be ignored. + + + + + Performs a coordinate transformation on an array of vectors using the given . + + The array of coordinate vectors to trasnform. + The transformation . + The array for which the transformed vectors are stored. + This array may be the same array as . + Thrown when or is null. + Thrown when is shorter in length than . + + A coordinate transform performs the transformation with the assumption that the w component + is one. The four dimensional vector obtained from the transformation operation has each + component in the vector divided by the w component. This forces the wcomponent to be one and + therefore makes the vector homogeneous. The homogeneous vector is often prefered when working + with coordinates as the w component can safely be ignored. + + + + + Performs a normal transformation using the given . + + The normal vector to transform. + The transformation . + When the method completes, contains the transformed normal. + + A normal transform performs the transformation with the assumption that the w component + is zero. This causes the fourth row and fourth collumn of the matrix to be unused. The + end result is a vector that is not translated, but all other transformation properties + apply. This is often prefered for normal vectors as normals purely represent direction + rather than location because normal vectors should not be translated. + + + + + Performs a normal transformation using the given . + + The normal vector to transform. + The transformation . + The transformed normal. + + A normal transform performs the transformation with the assumption that the w component + is zero. This causes the fourth row and fourth collumn of the matrix to be unused. The + end result is a vector that is not translated, but all other transformation properties + apply. This is often prefered for normal vectors as normals purely represent direction + rather than location because normal vectors should not be translated. + + + + + Performs a normal transformation on an array of vectors using the given . + + The array of normal vectors to transform. + The transformation . + The array for which the transformed vectors are stored. + This array may be the same array as . + Thrown when or is null. + Thrown when is shorter in length than . + + A normal transform performs the transformation with the assumption that the w component + is zero. This causes the fourth row and fourth collumn of the matrix to be unused. The + end result is a vector that is not translated, but all other transformation properties + apply. This is often prefered for normal vectors as normals purely represent direction + rather than location because normal vectors should not be translated. + + + + + Adds two vectors. + + The first vector to add. + The second vector to add. + The sum of the two vectors. + + + + Assert a vector (return it unchanged). + + The vector to assert (unchange). + The asserted (unchanged) vector. + + + + Subtracts two vectors. + + The first vector to subtract. + The second vector to subtract. + The difference of the two vectors. + + + + Reverses the direction of a given vector. + + The vector to negate. + A vector facing in the opposite direction. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + true if has a different value than ; otherwise, false. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Gets a value indicting whether this instance is normalized. + + + + + Gets or sets the component at the specified index. + + The value of the X or Y component, depending on the index. + The index of the component to access. Use 0 for the X component and 1 for the Y component. + The value of the component at the specified index. + Thrown when the is out of the range [0, 1]. + + + + Represents a three dimensional mathematical vector. + + + + + The size of the type, in bytes. + + + + + A with all of its components set to zero. + + + + + The X unit (1, 0, 0). + + + + + The Y unit (0, 1, 0). + + + + + The Z unit (0, 0, 1). + + + + + A with all of its components set to one. + + + + + The X component of the vector. + + + + + The Y component of the vector. + + + + + The Z component of the vector. + + + + + Initializes a new instance of the struct. + + The value that will be assigned to all components. + + + + Initializes a new instance of the struct. + + Initial value for the X component of the vector. + Initial value for the Y component of the vector. + Initial value for the Z component of the vector. + + + + Initializes a new instance of the struct. + + A vector containing the values with which to initialize the X and Y components. + Initial value for the Z component of the vector. + + + + Initializes a new instance of the struct. + + The values to assign to the X, Y, and Z components of the vector. This must be an array with three elements. + Thrown when is null. + Thrown when contains more or less than three elements. + + + + Calculates the length of the vector. + + The length of the vector. + + may be preferred when only the relative length is needed + and speed is of the essence. + + + + + Calculates the squared length of the vector. + + The squared length of the vector. + + This method may be preferred to when only a relative length is needed + and speed is of the essence. + + + + + Converts the vector into a unit vector. + + + + + Creates an array containing the elements of the vector. + + A three-element array containing the components of the vector. + + + + Adds two vectors. + + The first vector to add. + The second vector to add. + When the method completes, contains the sum of the two vectors. + + + + Adds two vectors. + + The first vector to add. + The second vector to add. + The sum of the two vectors. + + + + Subtracts two vectors. + + The first vector to subtract. + The second vector to subtract. + When the method completes, contains the difference of the two vectors. + + + + Subtracts two vectors. + + The first vector to subtract. + The second vector to subtract. + The difference of the two vectors. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + When the method completes, contains the scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Modulates a vector with another by performing component-wise multiplication. + + The first vector to modulate. + The second vector to modulate. + When the method completes, contains the modulated vector. + + + + Modulates a vector with another by performing component-wise multiplication. + + The first vector to modulate. + The second vector to modulate. + The modulated vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + When the method completes, contains the scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Reverses the direction of a given vector. + + The vector to negate. + When the method completes, contains a vector facing in the opposite direction. + + + + Reverses the direction of a given vector. + + The vector to negate. + A vector facing in the opposite direction. + + + + Returns a containing the 3D Cartesian coordinates of a point specified in Barycentric coordinates relative to a 3D triangle. + + A containing the 3D Cartesian coordinates of vertex 1 of the triangle. + A containing the 3D Cartesian coordinates of vertex 2 of the triangle. + A containing the 3D Cartesian coordinates of vertex 3 of the triangle. + Barycentric coordinate b2, which expresses the weighting factor toward vertex 2 (specified in ). + Barycentric coordinate b3, which expresses the weighting factor toward vertex 3 (specified in ). + When the method completes, contains the 3D Cartesian coordinates of the specified point. + + + + Returns a containing the 3D Cartesian coordinates of a point specified in Barycentric coordinates relative to a 3D triangle. + + A containing the 3D Cartesian coordinates of vertex 1 of the triangle. + A containing the 3D Cartesian coordinates of vertex 2 of the triangle. + A containing the 3D Cartesian coordinates of vertex 3 of the triangle. + Barycentric coordinate b2, which expresses the weighting factor toward vertex 2 (specified in ). + Barycentric coordinate b3, which expresses the weighting factor toward vertex 3 (specified in ). + A new containing the 3D Cartesian coordinates of the specified point. + + + + Restricts a value to be within a specified range. + + The value to clamp. + The minimum value. + The maximum value. + When the method completes, contains the clamped value. + + + + Restricts a value to be within a specified range. + + The value to clamp. + The minimum value. + The maximum value. + The clamped value. + + + + Calculates the cross product of two vectors. + + First source vector. + Second source vector. + When the method completes, contains he cross product of the two vectors. + + + + Calculates the cross product of two vectors. + + First source vector. + Second source vector. + The cross product of the two vectors. + + + + Calculates the distance between two vectors. + + The first vector. + The second vector. + When the method completes, contains the distance between the two vectors. + + may be preferred when only the relative distance is needed + and speed is of the essence. + + + + + Calculates the distance between two vectors. + + The first vector. + The second vector. + The distance between the two vectors. + + may be preferred when only the relative distance is needed + and speed is of the essence. + + + + + Calculates the squared distance between two vectors. + + The first vector. + The second vector. + When the method completes, contains the squared distance between the two vectors. + Distance squared is the value before taking the square root. + Distance squared can often be used in place of distance if relative comparisons are being made. + For example, consider three points A, B, and C. To determine whether B or C is further from A, + compare the distance between A and B to the distance between A and C. Calculating the two distances + involves two square roots, which are computationally expensive. However, using distance squared + provides the same information and avoids calculating two square roots. + + + + + Calculates the squared distance between two vectors. + + The first vector. + The second vector. + The squared distance between the two vectors. + Distance squared is the value before taking the square root. + Distance squared can often be used in place of distance if relative comparisons are being made. + For example, consider three points A, B, and C. To determine whether B or C is further from A, + compare the distance between A and B to the distance between A and C. Calculating the two distances + involves two square roots, which are computationally expensive. However, using distance squared + provides the same information and avoids calculating two square roots. + + + + + Calculates the dot product of two vectors. + + First source vector. + Second source vector. + When the method completes, contains the dot product of the two vectors. + + + + Calculates the dot product of two vectors. + + First source vector. + Second source vector. + The dot product of the two vectors. + + + + Converts the vector into a unit vector. + + The vector to normalize. + When the method completes, contains the normalized vector. + + + + Converts the vector into a unit vector. + + The vector to normalize. + The normalized vector. + + + + Performs a linear interpolation between two vectors. + + Start vector. + End vector. + Value between 0 and 1 indicating the weight of . + When the method completes, contains the linear interpolation of the two vectors. + + This method performs the linear interpolation based on the following formula. + start + (end - start) * amount + Passing a value of 0 will cause to be returned; a value of 1 will cause to be returned. + + + + + Performs a linear interpolation between two vectors. + + Start vector. + End vector. + Value between 0 and 1 indicating the weight of . + The linear interpolation of the two vectors. + + This method performs the linear interpolation based on the following formula. + start + (end - start) * amount + Passing a value of 0 will cause to be returned; a value of 1 will cause to be returned. + + + + + Performs a cubic interpolation between two vectors. + + Start vector. + End vector. + Value between 0 and 1 indicating the weight of . + When the method completes, contains the cubic interpolation of the two vectors. + + + + Performs a cubic interpolation between two vectors. + + Start vector. + End vector. + Value between 0 and 1 indicating the weight of . + The cubic interpolation of the two vectors. + + + + Performs a Hermite spline interpolation. + + First source position vector. + First source tangent vector. + Second source position vector. + Second source tangent vector. + Weighting factor. + When the method completes, contains the result of the Hermite spline interpolation. + + + + Performs a Hermite spline interpolation. + + First source position vector. + First source tangent vector. + Second source position vector. + Second source tangent vector. + Weighting factor. + The result of the Hermite spline interpolation. + + + + Performs a Catmull-Rom interpolation using the specified positions. + + The first position in the interpolation. + The second position in the interpolation. + The third position in the interpolation. + The fourth position in the interpolation. + Weighting factor. + When the method completes, contains the result of the Catmull-Rom interpolation. + + + + Performs a Catmull-Rom interpolation using the specified positions. + + The first position in the interpolation. + The second position in the interpolation. + The third position in the interpolation. + The fourth position in the interpolation. + Weighting factor. + A vector that is the result of the Catmull-Rom interpolation. + + + + Returns a vector containing the smallest components of the specified vectors. + + The first source vector. + The second source vector. + When the method completes, contains an new vector composed of the largest components of the source vectors. + + + + Returns a vector containing the largest components of the specified vectors. + + The first source vector. + The second source vector. + A vector containing the largest components of the source vectors. + + + + Returns a vector containing the smallest components of the specified vectors. + + The first source vector. + The second source vector. + When the method completes, contains an new vector composed of the smallest components of the source vectors. + + + + Returns a vector containing the smallest components of the specified vectors. + + The first source vector. + The second source vector. + A vector containing the smallest components of the source vectors. + + + + Projects a 3D vector from object space into screen space. + + The vector to project. + The X position of the viewport. + The Y position of the viewport. + The width of the viewport. + The height of the viewport. + The minimum depth of the viewport. + The maximum depth of the viewport. + The combined world-view-projection matrix. + When the method completes, contains the vector in screen space. + + + + Projects a 3D vector from object space into screen space. + + The vector to project. + The X position of the viewport. + The Y position of the viewport. + The width of the viewport. + The height of the viewport. + The minimum depth of the viewport. + The maximum depth of the viewport. + The combined world-view-projection matrix. + The vector in screen space. + + + + Projects a 3D vector from screen space into object space. + + The vector to project. + The X position of the viewport. + The Y position of the viewport. + The width of the viewport. + The height of the viewport. + The minimum depth of the viewport. + The maximum depth of the viewport. + The combined world-view-projection matrix. + When the method completes, contains the vector in object space. + + + + Projects a 3D vector from screen space into object space. + + The vector to project. + The X position of the viewport. + The Y position of the viewport. + The width of the viewport. + The height of the viewport. + The minimum depth of the viewport. + The maximum depth of the viewport. + The combined world-view-projection matrix. + The vector in object space. + + + + Returns the reflection of a vector off a surface that has the specified normal. + + The source vector. + Normal of the surface. + When the method completes, contains the reflected vector. + Reflect only gives the direction of a reflection off a surface, it does not determine + whether the original vector was close enough to the surface to hit it. + + + + Returns the reflection of a vector off a surface that has the specified normal. + + The source vector. + Normal of the surface. + The reflected vector. + Reflect only gives the direction of a reflection off a surface, it does not determine + whether the original vector was close enough to the surface to hit it. + + + + Orthogonalizes a list of vectors. + + The list of orthogonalized vectors. + The list of vectors to orthogonalize. + + Orthogonalization is the process of making all vectors orthogonal to each other. This + means that any given vector in the list will be orthogonal to any other given vector in the + list. + Because this method uses the modified Gram-Schmidt process, the resulting vectors + tend to be numerically unstable. The numeric stability decreases according to the vectors + position in the list so that the first vector is the most stable and the last vector is the + least stable. + + Thrown when or is null. + Thrown when is shorter in length than . + + + + Orthonormalizes a list of vectors. + + The list of orthonormalized vectors. + The list of vectors to orthonormalize. + + Orthonormalization is the process of making all vectors orthogonal to each + other and making all vectors of unit length. This means that any given vector will + be orthogonal to any other given vector in the list. + Because this method uses the modified Gram-Schmidt process, the resulting vectors + tend to be numerically unstable. The numeric stability decreases according to the vectors + position in the list so that the first vector is the most stable and the last vector is the + least stable. + + Thrown when or is null. + Thrown when is shorter in length than . + + + + Transforms a 3D vector by the given rotation. + + The vector to rotate. + The rotation to apply. + When the method completes, contains the transformed . + + + + Transforms a 3D vector by the given rotation. + + The vector to rotate. + The rotation to apply. + The transformed . + + + + Transforms an array of vectors by the given rotation. + + The array of vectors to transform. + The rotation to apply. + The array for which the transformed vectors are stored. + This array may be the same array as . + Thrown when or is null. + Thrown when is shorter in length than . + + + + Transforms a 3D vector by the given . + + The source vector. + The transformation . + When the method completes, contains the transformed . + + + + Transforms a 3D vector by the given . + + The source vector. + The transformation . + The transformed . + + + + Transforms an array of 3D vectors by the given . + + The array of vectors to transform. + The transformation . + The array for which the transformed vectors are stored. + Thrown when or is null. + Thrown when is shorter in length than . + + + + Performs a coordinate transformation using the given . + + The coordinate vector to transform. + The transformation . + When the method completes, contains the transformed coordinates. + + A coordinate transform performs the transformation with the assumption that the w component + is one. The four dimensional vector obtained from the transformation operation has each + component in the vector divided by the w component. This forces the wcomponent to be one and + therefore makes the vector homogeneous. The homogeneous vector is often prefered when working + with coordinates as the w component can safely be ignored. + + + + + Performs a coordinate transformation using the given . + + The coordinate vector to transform. + The transformation . + The transformed coordinates. + + A coordinate transform performs the transformation with the assumption that the w component + is one. The four dimensional vector obtained from the transformation operation has each + component in the vector divided by the w component. This forces the wcomponent to be one and + therefore makes the vector homogeneous. The homogeneous vector is often prefered when working + with coordinates as the w component can safely be ignored. + + + + + Performs a coordinate transformation on an array of vectors using the given . + + The array of coordinate vectors to trasnform. + The transformation . + The array for which the transformed vectors are stored. + This array may be the same array as . + Thrown when or is null. + Thrown when is shorter in length than . + + A coordinate transform performs the transformation with the assumption that the w component + is one. The four dimensional vector obtained from the transformation operation has each + component in the vector divided by the w component. This forces the wcomponent to be one and + therefore makes the vector homogeneous. The homogeneous vector is often prefered when working + with coordinates as the w component can safely be ignored. + + + + + Performs a normal transformation using the given . + + The normal vector to transform. + The transformation . + When the method completes, contains the transformed normal. + + A normal transform performs the transformation with the assumption that the w component + is zero. This causes the fourth row and fourth collumn of the matrix to be unused. The + end result is a vector that is not translated, but all other transformation properties + apply. This is often prefered for normal vectors as normals purely represent direction + rather than location because normal vectors should not be translated. + + + + + Performs a normal transformation using the given . + + The normal vector to transform. + The transformation . + The transformed normal. + + A normal transform performs the transformation with the assumption that the w component + is zero. This causes the fourth row and fourth collumn of the matrix to be unused. The + end result is a vector that is not translated, but all other transformation properties + apply. This is often prefered for normal vectors as normals purely represent direction + rather than location because normal vectors should not be translated. + + + + + Performs a normal transformation on an array of vectors using the given . + + The array of normal vectors to transform. + The transformation . + The array for which the transformed vectors are stored. + This array may be the same array as . + Thrown when or is null. + Thrown when is shorter in length than . + + A normal transform performs the transformation with the assumption that the w component + is zero. This causes the fourth row and fourth collumn of the matrix to be unused. The + end result is a vector that is not translated, but all other transformation properties + apply. This is often prefered for normal vectors as normals purely represent direction + rather than location because normal vectors should not be translated. + + + + + Adds two vectors. + + The first vector to add. + The second vector to add. + The sum of the two vectors. + + + + Assert a vector (return it unchanged). + + The vector to assert (unchange). + The asserted (unchanged) vector. + + + + Subtracts two vectors. + + The first vector to subtract. + The second vector to subtract. + The difference of the two vectors. + + + + Reverses the direction of a given vector. + + The vector to negate. + A vector facing in the opposite direction. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + true if has a different value than ; otherwise, false. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Gets a value indicting whether this instance is normalized. + + + + + Gets or sets the component at the specified index. + + The value of the X, Y, or Z component, depending on the index. + The index of the component to access. Use 0 for the X component, 1 for the Y component, and 2 for the Z component. + The value of the component at the specified index. + Thrown when the is out of the range [0, 2]. + + + + Represents a four dimensional mathematical vector. + + + + + The size of the type, in bytes. + + + + + A with all of its components set to zero. + + + + + The X unit (1, 0, 0, 0). + + + + + The Y unit (0, 1, 0, 0). + + + + + The Z unit (0, 0, 1, 0). + + + + + The W unit (0, 0, 0, 1). + + + + + A with all of its components set to one. + + + + + The X component of the vector. + + + + + The Y component of the vector. + + + + + The Z component of the vector. + + + + + The W component of the vector. + + + + + Initializes a new instance of the struct. + + The value that will be assigned to all components. + + + + Initializes a new instance of the struct. + + Initial value for the X component of the vector. + Initial value for the Y component of the vector. + Initial value for the Z component of the vector. + Initial value for the W component of the vector. + + + + Initializes a new instance of the struct. + + A vector containing the values with which to initialize the X, Y, and Z components. + Initial value for the W component of the vector. + + + + Initializes a new instance of the struct. + + A vector containing the values with which to initialize the X and Y components. + Initial value for the Z component of the vector. + Initial value for the W component of the vector. + + + + Initializes a new instance of the struct. + + The values to assign to the X, Y, Z, and W components of the vector. This must be an array with four elements. + Thrown when is null. + Thrown when contains more or less than four elements. + + + + Calculates the length of the vector. + + The length of the vector. + + may be preferred when only the relative length is needed + and speed is of the essence. + + + + + Calculates the squared length of the vector. + + The squared length of the vector. + + This method may be preferred to when only a relative length is needed + and speed is of the essence. + + + + + Converts the vector into a unit vector. + + + + + Creates an array containing the elements of the vector. + + A four-element array containing the components of the vector. + + + + Adds two vectors. + + The first vector to add. + The second vector to add. + When the method completes, contains the sum of the two vectors. + + + + Adds two vectors. + + The first vector to add. + The second vector to add. + The sum of the two vectors. + + + + Subtracts two vectors. + + The first vector to subtract. + The second vector to subtract. + When the method completes, contains the difference of the two vectors. + + + + Subtracts two vectors. + + The first vector to subtract. + The second vector to subtract. + The difference of the two vectors. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + When the method completes, contains the scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Modulates a vector with another by performing component-wise multiplication. + + The first vector to modulate. + The second vector to modulate. + When the method completes, contains the modulated vector. + + + + Modulates a vector with another by performing component-wise multiplication. + + The first vector to modulate. + The second vector to modulate. + The modulated vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + When the method completes, contains the scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Reverses the direction of a given vector. + + The vector to negate. + When the method completes, contains a vector facing in the opposite direction. + + + + Reverses the direction of a given vector. + + The vector to negate. + A vector facing in the opposite direction. + + + + Returns a containing the 4D Cartesian coordinates of a point specified in Barycentric coordinates relative to a 4D triangle. + + A containing the 4D Cartesian coordinates of vertex 1 of the triangle. + A containing the 4D Cartesian coordinates of vertex 2 of the triangle. + A containing the 4D Cartesian coordinates of vertex 3 of the triangle. + Barycentric coordinate b2, which expresses the weighting factor toward vertex 2 (specified in ). + Barycentric coordinate b3, which expresses the weighting factor toward vertex 3 (specified in ). + When the method completes, contains the 4D Cartesian coordinates of the specified point. + + + + Returns a containing the 4D Cartesian coordinates of a point specified in Barycentric coordinates relative to a 4D triangle. + + A containing the 4D Cartesian coordinates of vertex 1 of the triangle. + A containing the 4D Cartesian coordinates of vertex 2 of the triangle. + A containing the 4D Cartesian coordinates of vertex 3 of the triangle. + Barycentric coordinate b2, which expresses the weighting factor toward vertex 2 (specified in ). + Barycentric coordinate b3, which expresses the weighting factor toward vertex 3 (specified in ). + A new containing the 4D Cartesian coordinates of the specified point. + + + + Restricts a value to be within a specified range. + + The value to clamp. + The minimum value. + The maximum value. + When the method completes, contains the clamped value. + + + + Restricts a value to be within a specified range. + + The value to clamp. + The minimum value. + The maximum value. + The clamped value. + + + + Calculates the distance between two vectors. + + The first vector. + The second vector. + When the method completes, contains the distance between the two vectors. + + may be preferred when only the relative distance is needed + and speed is of the essence. + + + + + Calculates the distance between two vectors. + + The first vector. + The second vector. + The distance between the two vectors. + + may be preferred when only the relative distance is needed + and speed is of the essence. + + + + + Calculates the squared distance between two vectors. + + The first vector. + The second vector. + When the method completes, contains the squared distance between the two vectors. + Distance squared is the value before taking the square root. + Distance squared can often be used in place of distance if relative comparisons are being made. + For example, consider three points A, B, and C. To determine whether B or C is further from A, + compare the distance between A and B to the distance between A and C. Calculating the two distances + involves two square roots, which are computationally expensive. However, using distance squared + provides the same information and avoids calculating two square roots. + + + + + Calculates the squared distance between two vectors. + + The first vector. + The second vector. + The squared distance between the two vectors. + Distance squared is the value before taking the square root. + Distance squared can often be used in place of distance if relative comparisons are being made. + For example, consider three points A, B, and C. To determine whether B or C is further from A, + compare the distance between A and B to the distance between A and C. Calculating the two distances + involves two square roots, which are computationally expensive. However, using distance squared + provides the same information and avoids calculating two square roots. + + + + + Calculates the dot product of two vectors. + + First source vector + Second source vector. + When the method completes, contains the dot product of the two vectors. + + + + Calculates the dot product of two vectors. + + First source vector. + Second source vector. + The dot product of the two vectors. + + + + Converts the vector into a unit vector. + + The vector to normalize. + When the method completes, contains the normalized vector. + + + + Converts the vector into a unit vector. + + The vector to normalize. + The normalized vector. + + + + Performs a linear interpolation between two vectors. + + Start vector. + End vector. + Value between 0 and 1 indicating the weight of . + When the method completes, contains the linear interpolation of the two vectors. + + This method performs the linear interpolation based on the following formula. + start + (end - start) * amount + Passing a value of 0 will cause to be returned; a value of 1 will cause to be returned. + + + + + Performs a linear interpolation between two vectors. + + Start vector. + End vector. + Value between 0 and 1 indicating the weight of . + The linear interpolation of the two vectors. + + This method performs the linear interpolation based on the following formula. + start + (end - start) * amount + Passing a value of 0 will cause to be returned; a value of 1 will cause to be returned. + + + + + Performs a cubic interpolation between two vectors. + + Start vector. + End vector. + Value between 0 and 1 indicating the weight of . + When the method completes, contains the cubic interpolation of the two vectors. + + + + Performs a cubic interpolation between two vectors. + + Start vector. + End vector. + Value between 0 and 1 indicating the weight of . + The cubic interpolation of the two vectors. + + + + Performs a Hermite spline interpolation. + + First source position vector. + First source tangent vector. + Second source position vector. + Second source tangent vector. + Weighting factor. + When the method completes, contains the result of the Hermite spline interpolation. + + + + Performs a Hermite spline interpolation. + + First source position vector. + First source tangent vector. + Second source position vector. + Second source tangent vector. + Weighting factor. + The result of the Hermite spline interpolation. + + + + Performs a Catmull-Rom interpolation using the specified positions. + + The first position in the interpolation. + The second position in the interpolation. + The third position in the interpolation. + The fourth position in the interpolation. + Weighting factor. + When the method completes, contains the result of the Catmull-Rom interpolation. + + + + Performs a Catmull-Rom interpolation using the specified positions. + + The first position in the interpolation. + The second position in the interpolation. + The third position in the interpolation. + The fourth position in the interpolation. + Weighting factor. + A vector that is the result of the Catmull-Rom interpolation. + + + + Returns a vector containing the smallest components of the specified vectors. + + The first source vector. + The second source vector. + When the method completes, contains an new vector composed of the largest components of the source vectors. + + + + Returns a vector containing the largest components of the specified vectors. + + The first source vector. + The second source vector. + A vector containing the largest components of the source vectors. + + + + Returns a vector containing the smallest components of the specified vectors. + + The first source vector. + The second source vector. + When the method completes, contains an new vector composed of the smallest components of the source vectors. + + + + Returns a vector containing the smallest components of the specified vectors. + + The first source vector. + The second source vector. + A vector containing the smallest components of the source vectors. + + + + Orthogonalizes a list of vectors. + + The list of orthogonalized vectors. + The list of vectors to orthogonalize. + + Orthogonalization is the process of making all vectors orthogonal to each other. This + means that any given vector in the list will be orthogonal to any other given vector in the + list. + Because this method uses the modified Gram-Schmidt process, the resulting vectors + tend to be numerically unstable. The numeric stability decreases according to the vectors + position in the list so that the first vector is the most stable and the last vector is the + least stable. + + Thrown when or is null. + Thrown when is shorter in length than . + + + + Orthonormalizes a list of vectors. + + The list of orthonormalized vectors. + The list of vectors to orthonormalize. + + Orthonormalization is the process of making all vectors orthogonal to each + other and making all vectors of unit length. This means that any given vector will + be orthogonal to any other given vector in the list. + Because this method uses the modified Gram-Schmidt process, the resulting vectors + tend to be numerically unstable. The numeric stability decreases according to the vectors + position in the list so that the first vector is the most stable and the last vector is the + least stable. + + Thrown when or is null. + Thrown when is shorter in length than . + + + + Transforms a 4D vector by the given rotation. + + The vector to rotate. + The rotation to apply. + When the method completes, contains the transformed . + + + + Transforms a 4D vector by the given rotation. + + The vector to rotate. + The rotation to apply. + The transformed . + + + + Transforms an array of vectors by the given rotation. + + The array of vectors to transform. + The rotation to apply. + The array for which the transformed vectors are stored. + This array may be the same array as . + Thrown when or is null. + Thrown when is shorter in length than . + + + + Transforms a 4D vector by the given . + + The source vector. + The transformation . + When the method completes, contains the transformed . + + + + Transforms a 4D vector by the given . + + The source vector. + The transformation . + The transformed . + + + + Transforms an array of 4D vectors by the given . + + The array of vectors to transform. + The transformation . + The array for which the transformed vectors are stored. + This array may be the same array as . + Thrown when or is null. + Thrown when is shorter in length than . + + + + Adds two vectors. + + The first vector to add. + The second vector to add. + The sum of the two vectors. + + + + Assert a vector (return it unchanged). + + The vector to assert (unchange). + The asserted (unchanged) vector. + + + + Subtracts two vectors. + + The first vector to subtract. + The second vector to subtract. + The difference of the two vectors. + + + + Reverses the direction of a given vector. + + The vector to negate. + A vector facing in the opposite direction. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Scales a vector by the given value. + + The vector to scale. + The amount by which to scale the vector. + The scaled vector. + + + + Tests for equality between two objects. + + The first value to compare. + The second value to compare. + true if has the same value as ; otherwise, false. + + + + Tests for inequality between two objects. + + The first value to compare. + The second value to compare. + true if has a different value than ; otherwise, false. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Gets a value indicting whether this instance is normalized. + + + + + Gets or sets the component at the specified index. + + The value of the X, Y, Z, or W component, depending on the index. + The index of the component to access. Use 0 for the X component, 1 for the Y component, 2 for the Z component, and 3 for the W component. + The value of the component at the specified index. + Thrown when the is out of the range [0, 3]. + + + + RenderLoop provides a rendering loop infrastructure. + + + + + Runs the specified main loop in the specified context. + + + + + Runs the specified main loop for the specified windows form. + + The form. + The rendering callback. + + + + Gets a value indicating whether this instance is application idle. + + + true if this instance is application idle; otherwise, false. + + + + + Delegate for the rendering loop. + + + + + ProxyNativeWindow, used only to detect if the original window is destroyed + + + + + Initializes a new instance of the class. + + + + + Private WindowProc in order to handle NCDestroy message + + + + + Private rendering loop + + + + + A Renderable UserControl. + + + + + Initializes a new instance of the class. + + + + + Paints the background of the control. + + A that contains the event data. + + + + Raises the event. + + A that contains the event data. + + + + Default Rendering Form. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The text. + + + + Raises the event. + + A that contains the event data. + + + + Raises the event. + + A that contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Paints the background of the control. + + A that contains the event data. + + + + Raises the Pause Rendering event. + + The instance containing the event data. + + + + Raises the Resume Rendering event. + + The instance containing the event data. + + + + Raises the User resized event. + + The instance containing the event data. + + + + Raises the On App Activated event. + + The instance containing the event data. + + + + Raises the App Deactivated event + + The instance containing the event data. + + + + Raises the System Suspend event + + The instance containing the event data. + + + + Raises the System Resume event + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Override windows message loop handling. + + The Windows to process. + + + + Updates the screen. + + + + + Occurs when [app activated]. + + + + + Occurs when [app deactivated]. + + + + + Occurs when [monitor changed]. + + + + + Occurs when [pause rendering]. + + + + + Occurs when [resume rendering]. + + + + + Occurs when [screensaver]. + + + + + Occurs when [system resume]. + + + + + Occurs when [system suspend]. + + + + + Occurs when [user resized]. + + + + -- 2.11.0