久久久久人妻一区精品色,99久久精品免费观看国产,亚洲а∨天堂久久精品9966

梦在天�� — Fri, 09 Nov 2007 10:01:00 GMT

摘要: 代码�Q?//------------------------------------------------------------------------------// Name: dx9cs_multiple_vertex_buffers.cs//&n... 阅读全文

梦在天�� 2007-11-09 18:01 发表评论

梦在天�� — Fri, 09 Nov 2007 09:34:00 GMT

摘要: 代码�Q?using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Text;using System.Windows.Forms;us... 阅读全文

梦在天�� 2007-11-09 17:34 发表评论

为程序增加简单的声音提示(.net��装API --PlaySound())

梦在天�� — Thu, 06 Jul 2006 08:40:00 GMT

using System;
using System.Runtime.InteropServices;

namespace tonysound
{
     public class Sound
     {
         public static void Play( string strFileName, PlaySoundFlags soundFlags)
         {
            PlaySound( strFileName, IntPtr.Zero, soundFlags);
             // passes to Playsound the filename and a pointer
             // to the Flag
        }

        [DllImport( " winmm.dll " )] // inports the winmm.dll used for sound
         private static extern bool PlaySound( string szSound, IntPtr hMod, PlaySoundFlags flags );
    }

    [Flags] // enumeration treated as a bit field or set of flags
     public enum PlaySoundFlags: int
     {

        SND_SYNC = 0x0000 , /* play synchronously (default) */
        SND_ASYNC = 0x0001 , /* play asynchronously */
        SND_NODEFAULT = 0x0002 , /* silence (!default) if sound notfound */
        SND_LOOP = 0x0008 , /* loop the sound until nextsndPlaySound */
        SND_NOSTOP = 0x0010 , /* don't stop any currently playingsound */
        SND_NOWAIT = 0x00002000 , /* don't wait if the driver is busy */
        SND_FILENAME = 0x00020000 , /* name is file name */
        SND_RESOURCE = 0x00040004 /* name is resource name or atom */
    }
}

特点��是��单小�?只能在windows上用�?

梦在天�� 2006-07-06 16:40 发表评论

Managed directx ��查硬件支持和实现全屏昄��

梦在天�� — Thu, 22 Jun 2006 08:08:00 GMT

摘要: c#代码://-----------------------------------------------------------------------------// Name: dx9cs_fullscreen.cs// Author: Kevin Harris// Last Modified: 06/15/05// Description: T... 阅读全文

梦在天�� 2006-06-22 16:08 发表评论

managed directx 实现太阳�pȝ��模拟

梦在天�� — Thu, 22 Jun 2006 07:39:00 GMT

摘要: c#代码://------------------------------------------------------------------------------// Name: dx9cs_transforms.cs// Author: Kevin Harris// Last Modified: 06/28/05// Description: ... 阅读全文

梦在天�� 2006-06-22 15:39 发表评论

投媄变换

梦在天�� — Tue, 13 Jun 2006 06:33:00 GMT

投媄变换分类

把三�l�物体变��Z��l�图形表�C�的�q�程�U�Cؓ投媄变换�?/p>

投媄变换的分�c�L��况如下表所�C�：

世界坐标与观察坐�?/font>

物体在空间的表示是用世界坐标来表�C�，但是当�h们去观察物体�Ӟ��坐标�p�d��转化��察坐标系。这��需要在两个坐标�p�M��间进行�{换，可以通过�q�移、旋转实��C��世界坐标到观察坐标的变换�?/p>

�q�移后，用单位矢量法得到旋�{矩阵�Q?/p>

�?/font> Z_v 轴向��察��^面的法向 VPN�Q�其单位矢量n=VPN/|VPN|=(n_x,n_y,n_z)

�?/font> X_v 轴向��察方�?/font>PREF�Q�其单位矢量u=PREF/|PREF|=(u_x,u_y,u_z)

�?font face="Times New Roman">Y_v轴向的单位矢�?/font>v=u×n=�Q?/font>v_x�Q?/font>v_y�Q?/font>v_z�Q?/font>

因此世界坐标到观察坐标到变换矩阵为：

正��^行投影（三视图）

    投媄方向垂直于投影��^面的投媄�U�Cؓ正��^行投�?/a>�Q�我们通常所说的三视囑֝�属于正��^行投影。三视图的生成就是把 x �?/font> y �?/font> z 坐标�pȝ��形体投媄�?/font> z =0的��^面，变换�?/font> u �?/font> v �?/font> w 坐标�p�R��一般还需��三个视囑֜�一个��^面上��d��Q�这时就得到下面的变换公式，其中( a �Q?/font> b )�?/font> u �?/font> v 坐标�p�M��的��|�� t_x �?/font> t_y �?/font> t_z 均如图中所�C��?br />   1�Q�主视图
   2�Q�俯视图
   3�Q�侧视图

三视�?br />
斜��^行投�?/font>

投媄方向不垂直于投媄�q�面的��^行投��p��U�Cؓ斜��^行投�?/font>�Q�现在让我们来推导斜�q��投媄的变换矩��c��下图中的Z=0的坐标��^面�ؓ观察�q�面�Q�点�Q?/font> x �Q?/font> y �Q��ؓ点（ x �Q?/font> y �Q?/font> z �Q�在观察�q�面上的正��^行投影坐标，点（ x^´ �Q?/font> y ´ �Q��ؓ斜投影坐标。（ x �Q?/font> y �Q�与�Q?/font> x^´ �Q?/font> y ´ �Q�的距离�?/font> L �?

透视投媄

透视投媄的视�U�（投媄�U�）是从视点�Q�观察点�Q�出发，视线是不�q��的。不�q��于投影��^面的视线汇聚的一点称为灭点，在坐标��u上的灭点叫做�ȝ��炏V��主灭点数和投媄�q�面切割坐标轴的数量相对应。按照主灭点的个敎ͼ�透视投媄可分��Z��炚w��视、二炚w��视和三炚w��视�?

下面我们来推导简单的一炚w��视的投影公式�?/p>

从上�?/font>

P 点在观察�q�面上的投媄我们可以得到描述 P ´点的参数方程�Q?/font>

用齐�ơ坐标表�C�Zؓ�Q?/p>

http://jpkc.swjtu.edu.cn/C15/imagination/jisuanjituxing/Chapter6/CG_Txt_6_018.htm

梦在天�� 2006-06-13 14:33 发表评论

三维几何变换

梦在天�� — Tue, 13 Jun 2006 06:11:00 GMT

三维几何变换

�׃��用齐�ơ坐标表�C�，三维几何变换的矩阉|��一�?阶方阵，其�Ş式如下：

     1�Q��^�U�d��?br />
     参照二维的��^�U�d��换，我们很容易得��C��l��^�U�d��换矩阵：

2�Q�羃攑֏��?br /> 直接考虑相对于参考点

�Q?/font> x_f �Q?/font> y_f �Q?/font> z_f �Q?/font> 的羃攑֏�换，其步骤�ؓ�Q?/font>

A. ��^�U�d��坐标原点处；
B. �q�行�~�放变换�Q?br /> C. ��参考点

�Q?/font> x_f �Q?/font> y_f �Q?/font> z_f �Q?/font> �U�d��原来位置
       则变换矩阵�ؓ�Q?br />
    3�Q�绕坐标轴的旋�{变换
    三维�I�间的旋转相对要复杂些，考虑��x��坐标�p�M��相对坐标原点�l�坐标��u旋�{ q 角的变换�Q?/font>

A.�l?/font> x 轴旋�?br />

B.�l?/font> y 轴旋�?br />

     C.�l?/font> z 轴旋�?br />

三维�I�间的��^�U�R��旋转及�~�放�C�意�?/font>

   4�Q�绕��L��轴的旋�{变换
   设旋转��u AB �׃�Q意一�?/font> A �Q?/font> x_a �Q?/font> y_a �Q?/font> z_a �Q�及其方向数( a �Q?/font> b �Q?/font> c )定义�Q?img height="29" src="http://necweb.neu.edu.cn/ncourse//tuxingxue/Chapter6/CG_Gif_6_288.gif" width="400" border="0" />

可以通过下列步骤来实�?/font> P 点的旋�{�Q?/font>

A. ��?/font> A 点移到坐标原炏V�?/font>

B. �?/p> AB 分别�l?/font> X 轴�?/font> Y 轴旋转适当角度�?/font> Z 轴重合�?/font>

D.作上�q�变换的逆操作，�?/font> AB 回到原来位置�?/font>

�?/font> AB �?/font> YOZ �q�面�?/font> XOZ �q�面的投�׃�� Z 轴的夹角�?br />

http://necweb.neu.edu.cn/ncourse//tuxingxue/Chapter6/CG_Txt_6_012.htm

梦在天�� 2006-06-13 14:11 发表评论

梦在天�� — Tue, 13 Jun 2006 06:10:00 GMT

二维囑�Ş的几何变�?/font>

正如我们在附录中提到的那��P��用齐�ơ坐标表�C�点的变换将非常方便�Q�因此在本节中所有的几何变换都将采用齐次坐标�q�行�q�算。二�l�齐�ơ坐标变换的矩阵的�Ş式是�Q?

�q�个矩阵每一个元素都是有�Ҏ��含义的�?br /> 形进行��^�U�d��换；[ g h ]是对囑�Ş作投影变换；[ i ]则是对图形整体进行羃攑֏�换�?br />1�Q��^�U�d��?

2�Q�羃攑֏��?

3�Q�旋转变�?img height="28" src="http://necweb.neu.edu.cn/ncourse//tuxingxue/Chapter6/CG_Gif_6_291.gif" width="502" border="0" />

4�Q�对�U�变�?br />

对称变换其实只是 a �?/font> b �?/font> d �?/font> e �?/font>0�?/font>1�{�特�D��g�生的一些特�D�效果。例如：

�?/font> b = d =0�Q?/font> a =-1�Q?/font> e =1时有 x ^´=-x�Q?/font>y^´=y�Q��生与y轴对�U�的囑�Ş�?/i>

�?/font> b = d =0�Q?/font> a =-1�Q?/font> e =-1时有 x ^´=x�Q?/font>y^´=-y�Q��生与x轴对�U�的囑�Ş�?/font>

�?/font> b = d =0�Q?/font> a = e =-1时有 x ^´=-x�Q?/font>y^´=-y�Q��生与原点对称的图形�?/font>

�?/font> b = d =1�Q?/font> a = e =0时有 x ^´=y�Q?/font>y^´=x�Q��生与直线y=x对称的图形�?/font>

�?/font> b = d =-1�Q?/font> a = e =0时有 x ^´=-y�Q?/font>y^´=-x�Q��生与直线y=-x对称的图形�?/font>

5�Q�错切变�?br />

�?/font> d =0�Ӟ��x^´=x+by�Q?/font>y^´=y�Q�此�Ӟ��囑�Ş�?/font>y坐标不变�Q?/font>x坐标随初值�?�Q?/font>x�Q?/font>y�Q�及变换�p�L��b作线性变化�?/font>

�?/font> b =0�Ӟ��x^´=x�Q?/font>y^´=dx+y�Q�此�Ӟ��囑�Ş�?/font>x坐标不变�Q?/font>y坐标随初值�?�Q?/font>x�Q?/font>y�Q�及变换�p�L��d作线性变化�?/font>

6�Q�复合变�?/p>

如果囑�Ş要做一�ơ以上的几何变换�Q�那么可以将各个变换矩阵�l�合��h��q�行一步到位的变换。复合变换有如下的性质�Q?/font>

复合�q�移
对同一囑�Ş做两�ơ��^�Uȝ��当于��两�ơ的�q�移两加��h��Q?img height="63" src="http://necweb.neu.edu.cn/ncourse//tuxingxue/Chapter6/CG_Gif_6_224.gif" width="516" border="0" />

复合�~�放
两次�q�箋的羃攄��当于��羃放操作相乘：

复合旋�{
两次�q�箋的旋转相当于��两�ơ的旋�{角度相加�Q?img height="50" src="http://necweb.neu.edu.cn/ncourse//tuxingxue/Chapter6/CG_Gif_6_283.gif" width="509" border="0" />
�~�放、旋转变换都与参考点有关�Q�上面进行的各种变换都是以原点�ؓ参考点的。如果相�Ҏ��个一般的参考点�Q?/font> x_f �Q?/font> y_f �Q�作�~�放、旋转变换，相当于将该点�U�d��坐标原点处，然后�q�行�~�放、旋转变换，最后将�Q?/font> x_f �Q?/font> y_f �Q�点�U�d��原来的位�|�。切记复合变换时�Q�先作用的变换矩阵在右端�Q�后作用的变换矩阵在左端�?
关于�Q?/font> x_f �Q?/font> y_f �Q�点的羃攑֏��?

�l�（ x_f �Q?/font> y_f �Q�点的旋转变�?

http://necweb.neu.edu.cn/ncourse//tuxingxue/Chapter6/CG_Txt_6_011.htm　

梦在天�� 2006-06-13 14:10 发表评论

�H�口区到视图区的坐标变换

梦在天�� — Tue, 13 Jun 2006 06:05:00 GMT
�H�口区到视图区的坐标变换
    实际的窗口区与视囑֌�往往不一样大��，要在视图区正��地昄��形体的，必须��其从窗口区变换到视囑֌��?/font>

比例关系�Q�两者的变换公式为：



可以��单地��两者的关系表示为：

http://necweb.neu.edu.cn/ncourse//tuxingxue/Chapter6/CG_Txt_6_010.htm

梦在天�� 2006-06-13 14:05 发表评论

managed directx实现��d��buffer (Read and Write VertexBuffer and IndexBuffer Data)

梦在天�� — Fri, 09 Jun 2006 08:39:00 GMT

Read and Write VertexBuffer and IndexBuffer Data With GraphicsStreams

using System;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

public struct PositionNormalTexVertex
{
     public Vector3 Position;
     public Vector3 Normal;
     public    float Tu0, Tv0;
     public static readonly VertexFormats FVF = VertexFormats.Position | VertexFormats.Texture1;
}
public class Example
{
     public unsafe void   GraphicsStreamReadWrite()
     {
         // Create a vertex buffer in the managed pool
        VertexBuffer vb = new VertexBuffer( typeof (PositionNormalTexVertex), 100 , device, Usage.None, PositionNormalTexVertex.FVF, Pool.Managed);

         // First, fill an array of PositionNormalTexVertex elements with data.
        PositionNormalTexVertex[] vertices = new PositionNormalTexVertex[ 50 ];
         for ( int i = 0 ; i < 50 ; i ++ )
         {
             // fill the vertices with some data
            vertices[i].Position = new Vector3(3f,4f,5f);
        }

         // The size of the verticies are 32-bytes each (float3 (12) + float3 (12) + float(4) + float(4))
         // To lock 50 verticies, the size of the lock would be 1600 (32 * 50)
        GraphicsStream vbData =   vb.Lock( 0 , 1600 , LockFlags.None);

         // copy the vertex data into the vertex buffer
        vbData.Write(vertices);

         // Unlock the VB
        vb.Unlock();

         // This time, lock the entire VertexBuffer
        vbData =   vb.Lock( 0 , 3200 , LockFlags.None);

         // Cast the InternalDataPointer (a void pointer) to an array of verticies
        PositionNormalTexVertex * vbArray = (PositionNormalTexVertex * ) vbData.InternalDataPointer;

         for ( int i = 0 ; i < 100 ; i ++ )
         {
             // perform some operations on the data
            vbArray[i].Tu0 = i;
            vbArray[i].Tv0 = vbArray[i].Tu0 * 2 ;

            Console.WriteLine(vbArray[i].Tv0.ToString());
        }

         // Unlock the buffer
        vb.Unlock();
        vb.Dispose();
    }
}

Read and Write VertexBuffer Data With Arrays

using System;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

public struct PositionNormalTexVertex
{
    public Vector3 Position;
    public Vector3 Normal;
    public float Tu0, Tv0;
    public static readonly VertexFormats FVF = VertexFormats.Position | VertexFormats.Texture1;
}

public class Example
{
    public void ArrayBasedReadWrite()
    {
        //Create a vertex buffer in the managed pool
        VertexBuffer vb = new VertexBuffer(typeof(PositionNormalTexVertex), 100, device,                 Usage.None, PositionNormalTex1Vertex.FVF, Pool.Managed);

        //Fill an array of the appropriate type with the VB data using Lock()
        PositionNormalTexVertex[] vbData = (PositionNormalTexVertex[]) vb.Lock(0,                    typeof(PositionNormalTexVertex), LockFlags.None, 50);
        for(int i=0; i<50; i++)
        {
            //set your vertices to something
            vbData[i].Position = new Vector3(2f,2f,2f);
            vbData[i].Normal = new Vector3(1f,0f,0f);
            vbData[i].Tu0 = i;
            vbData[i].Tv0 = i;
        }
        //Unlock the vb before you can use it elsewhere
        vb.Unlock();

        //This lock overload simply locks the entire VB -- setting ReadOnly                     //can improve perf when reading a vertexbuffer
        vbData = (PositionNormalTexVertex[]) vb.Lock(0, LockFlags.ReadOnly);
        for(int i=0; i<100; i++)
        {
            //read some vertex data
            Console.WriteLine("Vertex " + i + "Tu: " +  vbData[i].Tu0 + " , Tv: " + vbData[i].Tv0);
        }

        //Unlock the buffer
        vb.Unlock();

        vb.Dispose();
    }
}

梦在天�� 2006-06-09 16:39 发表评论

Managed directx -----the different of transformed vertex and untransformed vertex

梦在天�� — Fri, 09 Jun 2006 08:33:00 GMT
transformed vertex : 默认的有视口,不需要再建立camara.

public void OnCreateVertexBuffer(object sender, EventArgs e)
        {
            VertexBuffer vb = (VertexBuffer)sender;
            GraphicsStream stm = vb.Lock(0, 0, 0);
            CustomVertex.TransformedColored[] verts = new CustomVertex.TransformedColored[3];

            verts[0].X=150;verts[0].Y=50;verts[0].Z=0.5f; verts[0].Rhw=5; verts[0].Color = System.Drawing.Color.Red.ToArgb();
            verts[1].X=250;verts[1].Y=250;verts[1].Z=0.5f; verts[1].Rhw=5; verts[1].Color = System.Drawing.Color.Yellow.ToArgb();
            verts[2].X=50;verts[2].Y=250;verts[2].Z=0.5f; verts[2].Rhw=5; verts[2].Color = System.Drawing.Color.SkyBlue.ToArgb();
            stm.Write(verts);
            vb.Unlock();
        }
        private void Render()
        {
            if (device == null)
                return;

            //Clear the backbuffer to a blue color (ARGB = 000000ff)
            device.Clear(ClearFlags.Target, System.Drawing.Color.Blue, 1.0f, 0);
            //Begin the scene
            device.BeginScene();

            device.SetStreamSource( 0, vertexBuffer, 0);
            device.VertexFormat = CustomVertex.TransformedColored.Format;
            device.DrawPrimitives(PrimitiveType.TriangleList, 0, 1);
            //End the scene
            device.EndScene();
            device.Present();
        }

untransformed vertex : 必须的manual建立camare��L��C?br />
public void OnCreateVertexBuffer(object sender, EventArgs e)
        {
            VertexBuffer vb = (VertexBuffer)sender;
            CustomVertex.PositionColored[] verts = (CustomVertex.PositionColored[])vb.Lock(0,0);
            verts[0].X=-1.0f; verts[0].Y=-1.0f; verts[0].Z=0.0f; verts[0].Color = System.Drawing.Color.DarkGoldenrod.ToArgb();
            verts[1].X=1.0f; verts[1].Y=-1.0f ;verts[1].Z=0.0f; verts[1].Color = System.Drawing.Color.MediumOrchid.ToArgb();
            verts[2].X=0.0f; verts[2].Y=1.0f; verts[2].Z = 0.0f; verts[2].Color = System.Drawing.Color.Cornsilk.ToArgb();
            vb.Unlock();
        }

        private void Render()
        {
            if (device == null)
                return;

            if (pause)
                return;

            //Clear the backbuffer to a blue color
            device.Clear(ClearFlags.Target, System.Drawing.Color.Blue, 1.0f, 0);
            //Begin the scene
            device.BeginScene();
            // Setup the world, view, and projection matrices
            SetupMatrices();

            device.SetStreamSource(0, vertexBuffer, 0);
            device.VertexFormat = CustomVertex.PositionColored.Format;
            device.DrawPrimitives(PrimitiveType.TriangleList, 0, 1);
            //End the scene
            device.EndScene();
            device.Present();
        }

        private void SetupMatrices()
        {
            // For our world matrix, we will just rotate the object about the y-axis.

            // Set up the rotation matrix to generate 1 full rotation (2*PI radians)
            // every 1000 ms. To avoid the loss of precision inherent in very high
            // floating point numbers, the system time is modulated by the rotation
            // period before conversion to a radian angle.
            int  iTime  = Environment.TickCount % 1000;
            float fAngle = iTime * (2.0f * (float)Math.PI) / 1000.0f;
            device.Transform.World = Matrix.RotationY( fAngle );

            // Set up our view matrix. A view matrix can be defined given an eye point,
            // a point to lookat, and a direction for which way is up. Here, we set the
            // eye five units back along the z-axis and up three units, look at the
            // origin, and define "up" to be in the y-direction.
            device.Transform.View = Matrix.LookAtLH( new Vector3( 0.0f, 3.0f,-5.0f ), new Vector3( 0.0f, 0.0f, 0.0f ), new Vector3( 0.0f, 1.0f, 0.0f ) );

            // For the projection matrix, we set up a perspective transform (which
            // transforms geometry from 3D view space to 2D viewport space, with
            // a perspective divide making objects smaller in the distance). To build
            // a perpsective transform, we need the field of view (1/4 pi is common),
            // the aspect ratio, and the near and far clipping planes (which define at
            // what distances geometry should be no longer be rendered).
            device.Transform.Projection = Matrix.PerspectiveFovLH( (float)Math.PI / 4, 1.0f, 1.0f, 100.0f );
        }
看好�?多了一个徏立matrix的function: 她的作用看代码喽!!!~~~~~~~~~~~~~~

梦在天�� 2006-06-09 16:33 发表评论

Managed Directx ---world matrix , projection matrix , view matrix

梦在天�� — Fri, 09 Jun 2006 07:07:00 GMT

Set Up a View Matrix

(^_^,只能看到projection以后��锥上下截面间的部分)
The three input vectors represent the following, respectively:

The eye point: [0, 3, -5].     (眼睛)

The camera look-at target: the origin [0, 0, 0]. (眼睛要看的东�?

The current world's up-direction: usually [0, 1, 0].   (指出那边是上�?

using Microsoft.DirectX.Direct3D;

Device device = null ;   // Create rendering device.

// Set up the view matrix. A view matrix can be defined given an eye point,
//    a point to view, and a direction for which way is up. Here, you set
//    the eye five units back along the z-axis and up three units, view the
//    origin, and define "up" to be in the y-direction.

device.Transform.View = Microsoft.DirectX.Matrix.LookAtLH(
                             new Vector3( 0.0f , 3.0f , - 5.0f ),
                             new Vector3( 0.0f , 0.0f , 0.0f ),
                             new Vector3( 0.0f , 1.0f , 0.0f ));

Set Up a Projection Matrix

(project以后得到我们能够看到的所�?一个棱锥上下截面间的部�?
This example demonstrates how to set up the projection transformation matrix, which transforms 3-D camera or view space coordinates into 2-D screen coordinates.
See the following C# code example, the Projection transformation matrix is set to be equal to the left-handed (LH) PerspectiveFovLH matrix. Input arguments to PerspectiveFovLH are as follows.
Field of view in radians: pi/4. (一般都�?/4 pi)
Aspect ratio, or view-space height divided by width: 1, for a square window. (长宽的比)
Near clipping plane distance: 1 unit.     (��ȝ��睛近的点,��x��锥的上面)
Far clipping plane distance: 100 units. (��ȝ��睛远的点,��x��锥的下面)

using Microsoft.DirectX;

Direct3D.Device device = null;  // Create rendering device.

// For the projection matrix, you set up a perspective transform (which
//   transforms geometry from 3-D view space to 2-D viewport space, with
//   a perspective divide making objects smaller in the distance). To build
//   a perspective transform, you need the field of view (1/4 pi is common),
//   the aspect ratio, and the near and far clipping planes (which define
//   the distances at which geometry should no longer be rendered).

device.Transform.Projection = Matrix.PerspectiveFovLH(
                              (float)Math.PI / 4, 1.0f, 1.0f, 100.0f );

What Is a World Transformation?
A world transformation changes coordinates from model space, where vertices are defined relative to a model's local origin, to world space, where vertices are defined relative to an origin common to all of the objects in a scene. In essence, the world transformation places a model into the world; hence its name.

Setting Up a World Matrix
As with any other transformation, you create the world transformation by concatenating a series of transformation matrices into a single matrix that contains the sum total of their effects. In the simplest case, when a model is at the world origin and its local coordinate axes are oriented the same as world space, the world matrix is the identity matrix. More commonly, the world matrix is a combination of a translation into world space and possibly one or more rotations to turn the model as needed.

The following C# code example, from a fictitious 3-D model class written in C#, creates a world matrix that includes three rotations to orient a model and a translation to relocate it relative to its position in world space.

public class ModelClass
{
   private float xPos=0;
   private float yPos=0;
   private float zPos=0;

   private float Pitch=0;
   private float Yaw=0;
   private float Roll=0;

   //Other model properties and methods

   public Matrix MakeWorldMatrix(Matrix worldMatrix)
   {
      worldMatrix.Translate(xPos,yPos,zPos);

      Matrix matRot = Matrix.Identity;

      matRot.RotateYawPitchRoll(Yaw,Pitch,Roll);

      worldMatrix = Matrix.Multiply(matRot, worldMatrix);

      return worldMatrix;

   }
}

Note: Direct3D uses the world and view matrices that you set to configure several internal data structures. Each time you set a new world or view matrix, the system recalculates the associated internal structures. Setting these matrices frequently—for example, thousands of times per frame—is computationally time-consuming. You can minimize the number of required calculations by concatenating your world and view matrices into a world-view matrix that you set as the world matrix, and then setting the view matrix to the identity. Keep cached copies of individual world and view matrices so that you can modify, concatenate, and reset the world matrix as needed. For clarity, Direct3D samples in this documentation rarely employ this optimization.

梦在天�� 2006-06-09 15:07 发表评论

Managed DirectX ---- Using Matrices

梦在天�� — Wed, 17 May 2006 02:16:00 GMT
     摘要: // ----------------------------------------------------------------------------- // File: Matrices.cs // // Desc: Now that we know how to cr...  阅读全文

梦在天�� 2006-05-17 10:16 发表评论

Managed Directx --rendering vertices (使用VertexBuffer �q�行render)

梦在天�� — Fri, 12 May 2006 05:55:00 GMT
     摘要: // ----------------------------------------------------------------------------- // File: Vertices.cs // // Desc: In this tutorial, we are r...  阅读全文

梦在天�� 2006-05-12 13:55 发表评论

Managed DirectX --- create Device

梦在天�� — Tue, 09 May 2006 10:31:00 GMT
     摘要: // ----------------------------------------------------------------------------- // File: CreateDevice.cs // // Desc: This is the first tuto...  阅读全文

梦在天�� 2006-05-09 18:31 发表评论

Managed DirectX --- Matrix&Transform(Translation and Scaling and Rotation)

梦在天�� — Tue, 09 May 2006 08:10:00 GMT

一 Translation

The following transformation translates the point (x, y, z) to a new point (x', y', z').

You can manually create a translation matrix in managed code. The following C# code example shows the source code for a function that creates a matrix to translate vertices.

[C#]
private Matrix TranslateMatrix(float dx, float dy, float dz) { Matrix ret; ret = Matrix.Identity; ret.M41 = dx; ret.M42 = dy; ret.M43 = dz; return ret; }

For convenience, managed the Microsoft Direct3D supplies the Translation method.

�?Scaling

The following transformation scales the point (x, y, z) by arbitrary values in the x-, y-, and z-directions to a new point (x', y', z').

三 �?Rotation

The transformations described here are for left-handed coordinate systems, and so might be different from transformation matrices that you have seen elsewhere. For more information, see 3-D Coordinate Systems.

The following transformation rotates the point (x, y, z) around the x-axis, producing a new point (x', y', z').

The following transformation rotates the point around the y-axis.

The following transformation rotates the point around the z-axis.

In these example matrices, the Greek letter theta (?) stands for the angle of rotation, in radians. Angles are measured clockwise when looking along the rotation axis toward the origin.

In a managed application, use the Matrix.RotationX, Matrix.RotationY, and Matrix.RotationZ methods to create rotation matrices. The following C# code example demonstrates how the Matrix.RotationX method performs a rotation.

[C#]
private Matrix MatrixRotationX(float angle) { double sin, cos; sin = Math.Sin(angle); cos = Math.Cos(angle); Matrix ret; ret.M11 = 1.0f; ret.M12 = 0.0f; ret.M13 = 0.0f; ret.M14 = 0.0f; ret.M21 = 0.0f; ret.M22 = (float)cos; ret.M23 = (float)sin; ret.M24 = 0.0f; ret.M31 = 0.0f; ret.M32 = (float)-sin; ret.M33 = (float)cos; ret.M34 = 0.0f; ret.M41 = 0.0f; ret.M42 = 0.0f; ret.M43 = 0.0f; ret.M44 = 1.0f; return ret; }

四�?Matrix Concatenation

One advantage of using matrices is that you can combine the effects of two or more matrices by multiplying them. This means that, to rotate a model and then translate it to some location, you do not need to apply two matrices. Instead, you multiply the rotation and translation matrices to produce a composite matrix that contains all of their effects. This process, called matrix concatenation, can be written with the following formula.

In this formula, C is the composite matrix being created, and M₁ through M_n are the individual transformations that matrix C contains. In most cases, only two or three matrices are concatenated, but there is no limit.

Use the Matrix.Multiply method to perform matrix multiplication.

The order in which the matrix multiplication is performed is crucial. The preceding formula reflects the left-to-right rule of matrix concatenation. That is, the visible effects of the matrices that you use to create a composite matrix occur in left-to-right order. A typical world transformation matrix is shown in the following example. Imagine that you are creating the world transformation matrix for a stereotypical flying saucer. You would probably want to spin the flying saucer around its center - the y-axis of model space - and translate it to some other location in your scene. To accomplish this effect, you first create a rotation matrix, and then multiply it by a translation matrix, as shown in the following formula.

In this formula, R_y is a matrix for rotation about the y-axis, and T_w is a translation to some position in world coordinates.

The order in which you multiply the matrices is important because, unlike multiplying two scalar values, matrix multiplication is not commutative. Multiplying the matrices in the opposite order has the visual effect of translating the flying saucer to its world space position, and then rotating it around the world origin.

No matter what type of matrix you are creating, remember the left-to-right rule to ensure that you achieve the expected effects.

到底什么时候在左边什么时候在双��?

�ȝ��:

�?3-D Transformations

In applications that work with 3-D graphics, geometrical transformations can be used to do the following.

Express the location of an object relative to another object.

Rotate and size objects.

Change viewing positions, directions, and perspectives.

You can transform any point (x,y,z) into another point (x', y', z') using a 4 x 4 matrix.

Perform the following operations on (x, y, z) and the matrix to produce the point (x', y', z').

The most common transformations are translation, rotation, and scaling. You can combine the matrices that produce these effects into a single matrix to calculate several transformations at once.

梦在天�� 2006-05-09 16:10 发表评论

Managed DirectX start !

梦在天�� — Wed, 19 Apr 2006 05:56:00 GMT

DirectX 首次出现�?1995 �q�_��当时�U�Cؓ“GameSDK”。在其原始�Ş式中�Q�针对的目标是��?C �?C++ 的开发�h员。只有在 2002 �q?12 月该 API 的第一个托��版�?(9.0) 发布以来�Q�才可以使用 C# �?VB.NET 开�?DirectX�Q�实际上�Q�如果您希望�Q�那么可以��用�Q何符�?CLR 的语�a��Q��?/p>
虽然与非托管版本相比�Q�关于托��?DirectX 的性能争论很多�Q�但商业游戏已��用托��?DirectX �q�行创徏的事实应该能够从�Ҏ��上��^息这��L��争论。虽然某些需要极高性能的游戏可能需要��用非托管代码�Q�但大多数游戏可以��用托��代码或者结合��用托��和非托��代码进行创建。编写托��代码��开发�h员的效率更高�Q�从而编写出更多的代码，生成更安全的代码�?

安装 DirectX SDK 之后�Q�在 C:\WINDOWS\Microsoft.NET\Managed DirectX 应该有一个目录，在机器上安装的每个版本的 SDK 都有一个子目录。我机器上��用的已经是第四版了，因此我有四个子目录。在每个子目录中应该有九�?DLL 和九�?XML 文�g。由于托��环境中�?.NET 允许同一台机器上的同一�?DLL 文�g有多个版本，而不会引起以前被�U�Cؓ DLL Hell 的问题，所以我们可以��用多版本的托��?DirectX 库。这��允许您在安装新版本之后��L��地回滚到以前的版本�?

如果您以前有�?Windows 下处�?DLL 文�g的经验，您可能会担心在同一台计��机上安装同一个文件的多个版本会��生问题。自�?.NET 引入�q�行版本控制�Q�这些版本控刉��题就不复存在了。这意味着当新版本�?SDK 发布�Ӟ��您可以��用多个版本来��查兼�Ҏ��问题，而不必强�q�自��p��行升�U��?/p>
九个 DLL 文�g大致对应�?DirectX 中的十个命名�I�间。在创徏游戏�Ӟ��我们使用其中的大量命名空间来提供对输入设备、声韟뀁网�l�播放（当然�q�有 3D 囑�Ş�Q�的支持�?/p>

命名�I�间描述

Microsoft.DirectX

公共�c�d��数学�l�构

Microsoft.DirectX.Direct3D

3D 囑�Ş和助手库

Microsoft.DirectX.DirectDraw

Direct Draw 囑�Ş API。这是旧式命名空��_��您不需要��用它�?/p>

Microsoft.DirectX.DirectPlay

用于多玩家游戏的�|�络 API

Microsoft.DirectX.DirectSound

声音支持

Microsoft.DirectX.DirectInput

输入讑֤�支持�Q�例如，鼠标和游戏杆�Q?/p>

Microsoft.DirectX.AudioVideoPlayback

播放视频和音频（例如�Q�在 PC 上播�?DVD�Q?/p>

Microsoft.DirectX.Diagnostics

疑难解答

Microsoft.DirectX.Security

讉K��安全�?/p>

Microsoft.DirectX.Security.Permissions

讉K��安全权限

HEL和HAL

　　在图5.2中，可以看到在DirectX下有两个层面�Q�分别是HEL�Q�硬件模拟层�Q�和HAL�Q�硬件抽象层�Q�。这是一个约定：DirectX是一�U�非常有�q�见的设计思�\�Q�它假定可以通过��g来实现高�U�性能。但是，如果��g�q�不支持某些性能�Q�那怎么办呢�Q�这��是HAL和HEL双重模式设计思�\的基��?br />　　HAL�Q�硬件抽象层�Q�是接近��g的底层。它直接和硬件交��。该层通常有设备生产商提供的设备驱动程序。可以通过常规DirectX调用直接和硬件进行联�p�R��用HAL要求��g能够直接支持所要求的性能�Q�这时��用HAL�Q�就能够提高性能。例如，当绘制一个位图时�Q��用硬件要比��Y件更胜�Q该项工作�?br />　　当硬件不支持所要求的性能�Ӟ��使用HEL�Q�硬件仿真层�Q�。我们以使用视频卡旋转一个位图�ؓ例来说明。如果硬件不支持旋�{动作�Q�则使用HEL�Q��Y件算法取代硬件。很明显�q�样做速度要慢一些，但关键是�q�样做至��不会中断应用程序，应用�E�序仍然在运行，仅仅是速度慢一些而已。另外，HAL和HEL之间的切转是透明的。如果要求DirectX做某工作�Q�而HAL直接处理该工作，也就是硬件直接处理该��工作。否则，HEL��调用��Y件仿真来处理该工作�?br />

Section 1 �?Introduction

Section 1.1 �?What is DirectX?

DirectX is the name given to a series of API for running and displaying multimedia rich applications. Using it, you can have graphics, video, 3D animation, surround sound and so on. The different API’s available in DirectX are Direct Graphics, Direct Input, Direct Sound, Direct Play and Direct Show.

Direct Graphics deals with everything related to graphics. With it you can load 3D meshes, render textures, animate 3D models, light your scene, add particle effects and much more. It is concentrated more towards 3D making it ideal for rendering 3D graphics, although it will also work just as well doing 2D graphics too.
Direct Input is the API that allows you to use many different kinds of input devices such as keyboards, mice, joysticks, joy pads and so on. It gives you much more control than the Win32 API does, and is ideal for games.
Direct Sound does everything you could ever want to do with audio. You can play midi files and wav files and other types of music. You can add special effects such as an echo or flanging. You can also add 3D surround sound effects by telling Direct Sound to apply special 3D algorithms and so on. Again, this is ideal for games.
Direct Play is the networking API used mainly in games. If you wish to make a game run over a network then you can use DirectPlay?. There isn’t much more to say about that really.
Direct Show can be used for all kinds of multimedia tasks such as video playback. It is ideal for audio or video recording, editing and manipulation.

Section 1.2 - Assumptions

Readers should have a basic understanding of the C# language and should have at least enough experience using it to understand the examples. The code examples are fairly simple and don’t use anything overly complicated, but you should still have a firm grasp of the language nevertheless. If you have any experience with using previous versions of DirectX in other languages then this would certainly help, but isn’t a requirement. The tutorial assumes you’ve never used DirectX before.
I will be using the .Net framework version 1.1. Readers using the new .Net 2.0 Framework that comes with Microsoft Visual C# 2005 Express Edition should be able to convert the code without too much trouble. Most of it should be compatibl. I will be using the Microsoft Visual Studio .Net 2003 IDE so any screenshots or descriptions will explain how to perform the task in that IDE. If you are using a different IDE such as Sharp Develop, Borland C# Builder or Microsoft Visual C# 2005 Express Edition, then I assume that you’re competent enough in it’s use that you can understand how to do the tasks in your own IDE. You should at least know how to create a new project, add references to your project, add files and code to your project, save it, and build it. Obviously knowing how to do other important things such as use the debugger would be a strong advantage.
I will use the DirectX Summer Update 2004 SDK. That is: version 1.0.1901.0. There may be some slight incompatibilities with previous versions, but they shouldn’t be too hard to fix if you’re using a previous version. I suggest you get the update though if you don’t already have it.
Note that I won’t be using the DirectX wizards or any template files in my project. I’ll be showing you how to do everything yourself so that we can gain a deeper understanding of what’s actually going on and what we’re actually writing.

Section 2 �?Creating a New DirectX Project

Section 2.1 �?Creating a New Project

Start up your IDE. As I mentioned above, I use Microsoft Visual Studio .Net 2003. Start a new project, and save it. Choose either “Windows Application�?or “Console Application�?depending on which type of project you wish to make. If you installed DirectX9? properly then you should be able to create a new DirectX project, which has a wizard to guide you through creating a simple application. As I mentioned, I won’t be using this. I prefer to write the code myself to gain a deeper understanding of what is actually going on in my project.

Section 2.2 �?Adding the DirectX References

In order to use DirectX in your applications, you must add a reference to the assemblies. To do this in Microsoft Visual Studio .Net 2003 you can click the project menu and click “Add Reference�? or right click on the “References�?section in the project explorer, and click “Add Reference�?
Now you should be presented with the “Add Reference�?dialog. Make sure the �?Net�?tab is selected, and scroll down to “Microsoft.DirectX�? You will see that there are several entries. At the very least, add “Microsoft.DirectX�? The other assembly names reflect quite clearly what they contain. For example “Microsoft.DirectX.Direct3D�?is the 3D graphics API, “Microsoft.DirectX.DirectSound�?is the Direct Sound API and so on. Go ahead and add whichever ones you require.
Some of you may notice that you have 2 versions of each assembly with different versions. You will have this if you installed the Summer 2004 Update. I have one set using version 1.0.1901.0 and another set using version 1.0.900.0. I will be adding the assemblies with the newer version: 1.0.1901.0.

Adding the DirectX references in Microsoft Visual Studio .Net 2003.

Section 2.3 �?The “using�?Directives

You may wish to add some “using�?directives for the namespaces in DirectX. You should know what the “using�?directive does. Here are some simple ones for using Direct3D:

using Microsoft.DirectX; using Microsoft.DirectX.Direct3D;

Section 3 �?Direct Graphics Enumeration

Section 3.1 �?Enumerating Adapters and Display Modes

An adapter is basically a graphics card. Most systems will have just 1 adapter. Systems with multiple monitors may have more than 1 adapter. If you wish to support systems with multiple adapters then you will have to enumerate them, otherwise you can just use the default one. The code to enumerate and choose an adapter is incredibly simple though, so it’s worth the little bit of extra effort.
An adapter is described by an AdapterInformation? class located inside the Microsoft.DirectX.Direct3D namespace. This class has some useful properties such as the CurrentDisplayMode? property, which funnily enough, returns the current display mode; the AvailableDisplayModes? property that returns a list of supported display modes, which can be enumerated using a foreach loop; and an Information property, which returns an AdapterDetails? class. This class contains several useful properties which you can use to identify individual cards and so on. One of the most useful properties of this class is the Description property. This gives you a human readable description of the graphics card such as “NVIDIA GeForce2? MX/MX 400�?(My old crappy card). There are many other properties and methods inside the AdapterInformation? class too. Explore the properties and methods using the tooltips and the intellisense (Intellisense is the name given to the lists that pop up in the code editor containing all the accessible members of an object for those of you who don’t know what that is).
To actually enumerate an adapter, we use the Manager class located inside the Microsoft.DirectX.Direct3D namespace. You don’t create a new instance of this class as all of it’s methods are static. The Manager class contains a static property called “Adapters�?which returns a list of AdapterInformation? classes described above, that you can enumerate using a foreach loop. It really is that simple. If you wish to use the default adapter, or just want to know what it is at least, then you can get that simply by using Manager.Adapters.Default.
Here’s an example program showing the main things we’ve learned so far:

using System; using Microsoft.DirectX; using Microsoft.DirectX.Direct3D; class AdapterEnumeration { static void Main(string[] args) { foreach(AdapterInformation adapter in Manager.Adapters) { // Check whether or not this is the default adapter if(adapter.Equals(Manager.Adapters.Default)) { Console.WriteLine("This is the default adapter\n"); } // Write out some information about the adapter Console.WriteLine("" + adapter.Information.ToString() + "\n\nDisplay Modes:\n"); // Write out each display mode foreach(DisplayMode display in adapter.SupportedDisplayModes) { Console.WriteLine("{0}x{1} : {2} @ {3} Hz", display.Width, display.Height, display.Format, display.RefreshRate); } // Write out the current display mode Console.WriteLine ("\nCurrent Display Mode: {0}x{1} : {2} @ {3} Hz", adapter.CurrentDisplayMode.Width, adapter.CurrentDisplayMode.Height, adapter.CurrentDisplayMode.Format, adapter.CurrentDisplayMode.RefreshRate); Console.WriteLine("\n\n"); } Console.ReadLine(); } }

That’s extremely simple, I think you’ll agree. The output isn’t the nicest looking output in the world, but it shows you how to do it. You can make it look pretty quite easily. In a windows application you can add each adapter description to a combo box or some other suitable control. When an adapter in the combo box is selected, you could add information about that adapter to a listview, and add it’s available display modes to another combo box, selecting the current display mode by default. That’s how I usually do it, and that’s an example of the kind of things you can do with the very simple code above.
As a by the way, you can get a handle to the monitor associated with each adapter using the following code:

IntPtr MonitorHandle = Manager.GetAdapterMonitor(adapter.Adapter);

I’m not quite sure what you could do with that handle, but I’m sure it’s useful somewhere, such as with some Win32 API functions that return information about the monitor or something like that. Note that the “Adapter�?property of the AdapterInformation? class is the “adapter ordinal�?which is just a fancy name for the adapter number. The first one has ordinal 0, the second ordinal 1 and so on. Usually there will be just one default adapter with an adapter ordinal of 0.

Section 3.2 �?Device Capabilities (Caps)

Device Caps is one of those terms you will hear a lot with DirectX programming. Caps is simply short for Capabilities. The Device Caps are therefore just what the device is and isn’t capable of doing. There are literally hundreds of things you can check. Retrieving device capabilities is very simple. Again, you use the Manager class to do this. Here is a short snippet of code showing you how to do it:

AdapterInformation ai = Manager.Adapters.Default; Caps caps = Manager.GetDeviceCaps(ai.Adapter, DeviceType.Hardware);

There’s nothing hard there, is there? The only thing that might confuse you is the DeviceType?. The 2 main types are “DeviceType.Hardware�?and “DeviceType.Reference�? There is also another device type called a Software Device, but this is very rarely used. I think it’s something to do with plugging in your own software renderer or something. Using the hardware device type will query the capabilities of the graphics adapter. Using the reference device type will query the capabilities of software emulation, basically. A lot of drivers will be able to make up for lack of hardware features by providing software emulation. A common difference for example, is that the hardware will only usually be able to do a few active lights such as 8 or 16 whereas the reference device may be able to do an unlimited amount. The software device will be able to do pretty much everything, but it’s much slower than the hardware.
Anyway, back to the point. You can probably figure out how to use the Caps class by looking at the intellisense again. This is a very powerful way to learn about classes. Most of it should be fairly self explanatory. You can test for all kinds of things. The tooltips will explain what all of the properties mean. For example, if you want to see whether or not textures must be square, you can test that using the following code:

if(caps.TextureCaps.SupportsSquareOnly) { Console.WriteLine("Square textures only are supported"); }

As I mentioned, there are literally hundreds of things you can check for. They are all organised into sensible properties. For example, all texture capabilities are stored inside the TextureCaps? property, vertex processing capabilities are inside the VertexProcessingCaps? property and so on. You can explore it using the object browser as well as the intellisense. (Press F2 in Visual Studio .Net 2003 to open the object browser):

Exploring the Caps class inside the object browser.

Section 3.3 �?Adapter Formats and BackBuffer? Formats

There are 3 main questions I will answer in this section: What is a format? What is a backbuffer (format), and what is an adapter format?
In answer to the first question, the format is just the way that pixel data is encoded. For example, you may have 5 bits to store the amount of red, 6 bits to store the amount of green and another 5 bits to store the amount of blue. This adds up to 16 bits, or 2 bytes per pixel. As a by the way, we give green more bits for 2 reasons. Firstly, to make the pixel data up to 2 bytes without wasting a pixel, and secondly, we chose the green component because our eyes are more sensitive to green and can therefore distinguish between more shades of green than they can red or blue, so it makes sense to give the green component the extra bit. The 2 most common formats are 16 bit and 32 bit. There is a 24 bit format and there are 8 bit formats, but these are rarely used. Some formats have some bits set aside for an “alpha�?component. This is to do with something called alphablending, which is a type of transparency. You don’t need to know what that is exactly right now, but just bear in mind that some formats have an extra alpha component. Yet other formats have unused bits, denoted by “X�? For example, there is a 32 bit mode called “X8R8G8B8�?which means that the red, green and blue components are all 8 bits each, and there is an unused 8 bits to round the format up to 4 bytes per pixel. An example of a format with an alpha component is one called “A8R8G8B8�?which has the same as the other format, but instead of having an unused 8 bits, it uses the extra 8 bits for the alpha component.
Now in order to explain what the backbuffer format is, I suppose I better mention briefly what a backbuffer is. When you draw things on the screen, they aren’t all drawn at the same time obviously. So you may draw a tree, then draw a bush, then draw another tree, then draw a character, then draw a house for example. They are all drawn one after the other. There is a phenomena called “artifacts�?where the screen encounters a vertical resync (a refresh) while you’re in the middle of drawing your scene on to the screen. This results in flickering graphics where you can briefly see things being drawn on the screen. The way this is fixed is we draw everything offscreen to an area of memory, and only once the scene is finished, we draw this entire area of memory onto the screen at once. This way you don’t see each individual part being drawn. This area of memory where you do your drawing is called a “backbuffer�?and the process of drawing the backbuffer onto the screen is called “flipping�?or “presenting�? Hopefully the term “backbuffer format�?should be quite clear now that I’ve explained what a backbuffer is, and what a format is.
Now for the adapter format, this is basically just your display mode. The format of the pixels on the main screen. One question may arise from this �?why aren’t the backbuffer format and the adapter format the exact same? Well the answer to that is in most cases they are. Although there is one difference. In a backbuffer you can have an alpha component, but you can’t have an alpha component in the adapter format. This is why they may differ.

Section 3.4 �?Device Types

This is quite a short section. I’ve already mentioned device types before, but here it is again. There are 3 device types: Hardware, Software and Reference. Hardware means use the graphics card where possible, reference means use software emulation. And the software device is rarely used. It’s something to do with writing your own software renderer I think. Now you may be wondering why you would ever want to use software instead of hardware. Well there is actually a good reason. Because the reference device supports absolutely everything. You would need to fork out a huge amount of money to get a graphics card that can come anywhere near close to being able to do everything. I’m talking about a top of the range card �?the best you can get. The problem with software is that it’s painfully slow compared to using hardware. So if you just want to test out some features in your game that your graphics card doesn’t support, you can switch to software emulated mode and check that it works. Or if you just really want to use some feature not supported by the hardware so much that you’re willing to slow down everything to a crawl to get it to work then you can use software emulation for that. You probably wouldn’t want to do that in a game unless you want a frame rate of about 0.5 frames per second. That would be for an application such as a 3D rendering application, where you really want to have some special effect in your scene, and don’t care if it takes an extra hour to render (These things take hours anyway).

Section 3.5 �?Using Manager.CheckDeviceType

At this point I’ve explained the following things to you: how to enumerate adapters, how to enumerate display modes, device types and backbuffer and adapter formats. Now you need to begin choosing them. So choose an adapter, a device type, an adapter format (from your list of display modes), a backbuffer format, and a device type. Now you need to choose one more thing: whether or not you want to run this application in a window, or in full screen mode. You will need all of these to create a device (which I’ll explain later. Lets just say for now that it’s incredibly important). So now you’ve chosen all of these things. Unless you know what you’re doing or you got pretty lucky, they’re probably all incompatible with each other and wouldn’t work. Ideally you want to present a list of adapters to the user. Once they choose an adapter, you would then want to present a list of device types compatible with that adapter to them, and have them choose one of those. Once they’ve chosen an adapter and a device type, you would like them to choose a display mode (the important part being the format, for the adapter format). Once they’ve chosen that, you would then ideally like to present them with a list of backbuffer formats which are compatible with the adapter format to choose from. And finally, you want to present them with the option of fullscreen or windowed mode, if that’s still there.
The best way to do this is to check every possibly combination of the following: adapters, device types, available adapter formats, backbuffer formats, whether or not to use windowed or full screen mode. By checking all the combinations of the above, you’ll get a list of all the compatible combinations which you can present to the user whatever way you see fit. The method used to check these is Manager.CheckDeviceType. The following code snippet shows you how you can check all possible combinations. When you get a valid combination, you can add that to your combo boxes or list boxes or your arrays or whatever method of storing the combinations you choose.

DeviceType[] deviceTypes = new DeviceType[] {DeviceType.Hardware, DeviceType.Software, DeviceType.Reference}; Format[] backBufferFormats = new Format[] {Format.A8R8G8B8, Format.X8R8G8B8, Format.A2R10G10B10, Format.R5G6B5, Format.A1R5G5B5, Format.X1R5G5B5}; bool[] windowModes = new bool[] {true, false}; // For each adapter foreach (AdapterInformation adapter in Manager.Adapters) { ArrayList adapterFormats = new ArrayList(); // Build the list of adapter formats foreach (DisplayMode dispMode in adapter.SupportedDisplayModes) { if (!adapterFormats.Contains (dispMode.Format)) adapterFormats.Add (dispMode.Format); } foreach (DeviceType deviceType in deviceTypes) { foreach (Format adapterFormat in adapterFormats) { foreach (Format backBufferFormat in backBufferFormats) { foreach (bool windowMode in windowModes) { if (Manager.CheckDeviceType ( adapter.Adapter, deviceType, adapterFormat, backBufferFormat, windowMode)) { // *** This combination is valid! } } // windowMode } // backBufferFormat } // adapterFormat } // deviceType } // adapter

Section 3.6 �?Vertex Processing

The last thing we need before we can create a device (As I said earlier, this will be explained. Just know that it’s important. This is the main object we use for all our rendering) is a vertex processing type. I assume you’ve used something similar to the above code to enumerate all the possible combinations of adapters, device types, adapter/backbuffer formats and windowed or not and chosen one of each. Now before we can build a device, we need this vertex processing method. Basically the vertex processing method is just telling Direct3D where to do all of the vertex processing. How much should the hardware be involved, and how much should the software be involved, basically. Most cards these days should support hardware vertex processing. Lower end ones will support mixed vertex processing, where the processing is done by both hardware and software. Software only vertex processing will always work, but is slower. We can go through some methods to determine which type of processing is available like this:

Caps caps = Manager.GetDeviceCaps(Manager.Adapters.Default.Adapter, DeviceType.Hardware); if (caps.DeviceCaps.SupportsHardwareTransformAndLight) { if (caps.DeviceCaps.SupportsPureDevice) { Console.WriteLine ("Pure Device"); } Console.WriteLine ("Hardware Vertex Processing"); Console.WriteLine ("Mixed Vertex Processing"); } Console.WriteLine ("Software Vertex Processing");

You can see that first we get the device capabilities, as we use them to check the vertex processing available. Then we check if the device supports hardware processing. If it does, we know that at least it supports hardware and mixed processing. If it supports hardware processing, then we check if it supports the “pure device�?which means it also supports resterization and shading as well as just lighting and transformation. We know that software vertex processing will always be available so that’s a given.
Now you have everything you need to create a device. You can enumerate and choose an adapter, and a display mode, and a backbuffer format and a device type and finally you can choose whether or not to use windowed mode or full screen mode if it’s compatible with everything else you’ve chosen.

Section 3.7 �?Enumerating Depth Stencil Formats

There is one other main thing you will need to be able to enumerate �?depth stencil formats. Don’t worry about what these actually are, you will learn later. I’m just putting this in the enumeration section because that’s where it belongs �?it is afterall enumeration. Just know how to do it. You already know what a format is. This is done quite easily. We first just check the format is valid for the device, then check if it’s compatible with the backbuffer format. If so, then we can use it (You’ll see what it’s for later).

DepthFormat[] depthStencilFormats = new DepthFormat[] { DepthFormat.D16, DepthFormat.D15S1, DepthFormat.D24X8, DepthFormat.D24S8, DepthFormat.D24X4S4, DepthFormat.D32, }; foreach (DepthFormat depthStencilFormat in depthStencilFormats) { if(Manager.CheckDeviceFormat(adapter, deviceType, adapterFormat, Usage.DepthStencil, ResourceType.Surface, depthStencilFormat)) { if (Manager.CheckDepthStencilMatch(adapter, deviceType, adapterFormat, backbufferFormat, depthStencilFormat)) { // This depth stencil format is compatible } } }

Section 3.8 �?Final Word on Enumeration

Note that I’ve covered more than enough on enumeration for you to get started. There is plenty more that you can figure out on your own though. Also remember all the stuff in the device capabilities (device caps) classes that can be checked. You check that stuff as you need it though. Unfortunately, enumeration is quite boring. I should have probably told you that at the start. We’ll start doing some more interesting stuff in the next section.

Section 4 �?Rendering Something

Section 4.1 �?Creating the Device

Finally we get on to this device I’ve mentioned so much in the enumeration section. What is a device? The device is the object we use in almost everything. It’s a representation of our actual adapter (well, in reality it’s driver). You will use the device to do all of the rendering (drawing, if I haven’t mentioned that yet) and lighting and so on. You can’t do very much without a device. So I think I’ve stressed just how important it is. Now to actually create a device is a little bit trickier than anything we’ve seen yet, but it’s still fairly trivial. Especially with all our enumeration done above.

// Assumes you have: // // AdapterInformation adapter; // DeviceType deviceType; // CreateFlags createFlags; // DisplayMode displayMode; // Format backbufferFormat; // bool windowed; PresentParameters presentation = new PresentParameters(); presentation.BackBufferFormat = backbufferFormat; presentation.BackBufferWidth = displayMode.Width; presentation.BackBufferHeight = displayMode.Height; presentation.SwapEffect = SwapEffect.Flip; presentation.Windowed = windowed; Device device = new Device( adapter.Adapter, deviceType, this, createFlags, presentation);

So first you need to choose an adapter, a device type, a vertex processing type (this is the createFlags variable) a display mode, a backbuffer format, and whether or not to use windowed mode. All of these are stored in the variables mentioned above. One you’ve chosen these, you then create a new PresentParameters? object. This stores information about the backbuffer, and the display mode, and other important presentation information. You can change things like the number of back buffers to use and so on. We just change the backbuffer format, width and height as appropriate. Then we change the swap effect. The swap effect is just how the backbuffer is presented to the screen. We just tell it to flip the backbuffer and the screen around so that the backbuffer now becomes drawn on the screen, and what was previously on the screen now becomes the backbuffer. Lastly, we set whether or not we want to use windowed mode or not. Now to finally create the device, you pass first the adapter ordinal, then the device type. The next parameter, “this�? must be a windows forms control! So this won’t work in console mode obviously. You must write the above code in a windows forms application. Using “this�?will just draw onto the form. You could also draw onto a picturebox or something else if you pleased. The next parameter is the create flags, or the vertex processing type that I talked about a lot above in the enumeration section. And lastly, you pass the presentation parameters. This should hopefully give us a working device.

Section 4.2 �?Rendering Something

Now we get to the fun part �?actually rendering! Don’t get too excited yet though, we’re only going to clear the window with a color. First we need to know where to actually render though. You could override the OnPaint? event and render everything in there. For a game or something, you will need a loop though. This is usually called “the game loop�? This game loop usually goes after all the initialization code. Just remember to show your form before entering the loop. So now we know roughly where to put our rendering code, how do we actually write it? Well, we’ll learn 2 new methods of the Device object: Clear and Present. The “Clear�?method simply clears the entire drawing area with your chosen color. The “Present�?method performs the “flip�? drawing the backbuffer to the screen. That’s all we’ll use right now. So here’s the code for a typical rendering loop:

while (Running) { device.Clear(ClearFlags.Target, System.Drawing.Color.Blue, 1.0f, 0); device.Present(); Application.DoEvents(); }

Notice that we have a variable, Running. This would be a boolean that you would set to true if your initialization was successful. Then when you want to end the loop, for example when the escape key is pressed, or the form is closing, then you set the Running variable to false. Notice that we also use Application.DoEvents to continue processing messages.

Section 4.3 �?A Complete Sample Application

using System; using System.Drawing; using System.Windows.Forms; using Microsoft.DirectX; using Microsoft.DirectX.Direct3D; public class MainForm : Form { Device device = null; ///
/// When the form is clicked, we close it and stop /// the application ///
protected override void OnClick(EventArgs e) { this.Close(); base.OnClick (e); } ///
/// In the constructor we initialize the device using /// the default adapter and the current display mode ///
public MainForm() { AdapterInformation adapter = Manager.Adapters.Default; PresentParameters presentation = new PresentParameters (); presentation.BackBufferFormat = adapter.CurrentDisplayMode.Format; presentation.BackBufferWidth = adapter.CurrentDisplayMode.Width; presentation.BackBufferHeight = adapter.CurrentDisplayMode.Height; presentation.SwapEffect = SwapEffect.Flip; presentation.Windowed = false; // Place it in a try catch block just //in case it goes wrong for // some reason. try { // To make things simple, we'll just //use the reference device, and // software vertex processing. //Although this will be extrelemly slow // it doesn't matter in this case. // It will definetly work on // all machines, so it saves us doing //enumeration for now. device = new Device (adapter.Adapter, DeviceType.Reference, this, CreateFlags.SoftwareVertexProcessing, presentation); } catch (DirectXException e) { MessageBox.Show (e.Message); return; } } ///
/// Clear the screen with a blue color ///
public void Render() { device.Clear(ClearFlags.Target, Color.Blue, 1.0f, 0); device.Present(); } ///
/// The entry point where the main render loop goes ///
static void Main() { using (MainForm form = new MainForm()) { form.Show(); while (form.Created) { form.Render(); Application.DoEvents(); } } } }

As a simple exercise you could try changing the application so that it exits when the escape key is pressed instead of clicked. Also, try changing the color to red. And if you like you can try making the program run in windowed mode by commenting all the backbuffer parameters in the presentation parameters and just change the Windowed property to true.

梦在天�� 2006-04-19 13:56 发表评论

命名�I�间	描述
Microsoft.DirectX	公共�c�d��数学�l�构
Microsoft.DirectX.Direct3D	3D 囑�Ş和助手库
Microsoft.DirectX.DirectDraw	Direct Draw 囑�Ş API。这是旧式命名空��_��您不需要��用它�?/p>
Microsoft.DirectX.DirectPlay	用于多玩家游戏的�\|�络 API
Microsoft.DirectX.DirectSound	声音支持
Microsoft.DirectX.DirectInput	输入讑֤�支持�Q�例如，鼠标和游戏杆�Q?/p>
Microsoft.DirectX.AudioVideoPlayback	播放视频和音频（例如�Q�在 PC 上播�?DVD�Q?/p>
Microsoft.DirectX.Diagnostics	疑难解答
Microsoft.DirectX.Security	讉K��安全�?/p>
Microsoft.DirectX.Security.Permissions	讉K��安全权限

久久久久人妻一区精品色,99久久精品免费观看国产,亚洲а∨天堂久久精品9966

为程序增加简单的声音提示(.net���装API --PlaySound())

Managed directx ���查硬件支持和实现全屏昄���

managed directx 实现太阳�pȝ��模拟

投媄变换

三维几何变换

�H�口区到视图区的坐标变换

managed directx实现��d��buffer (Read and Write VertexBuffer and IndexBuffer Data)

Read and Write VertexBuffer and IndexBuffer Data With GraphicsStreams

Read and Write VertexBuffer Data With Arrays

Managed directx -----the different of transformed vertex and untransformed vertex

Managed Directx ---world matrix , projection matrix , view matrix

Set Up a View Matrix

Set Up a Projection Matrix

What Is a World Transformation?

Setting Up a World Matrix

Managed DirectX ---- Using Matrices

Managed Directx --rendering vertices (使用VertexBuffer �q�行render)

Managed DirectX --- create Device

Managed DirectX --- Matrix&Transform(Translation and Scaling and Rotation)

一 Translation

�?Scaling

三 �?Rotation

四�?Matrix Concatenation

�?3-D Transformations

Managed DirectX start !

为程序增加简单的声音提示(.net��装API --PlaySound())

Managed directx ��查硬件支持和实现全屏昄��