Fanze 2013-07-31 22:28 发表评论

 1     /// 锁，利用临界区实现
 2     class ZLock{
 3         CRITICAL_SECTION m_CS ;
 4     public:
 5         ZLock(){
 6             ::InitializeCriticalSection(&m_CS) ;
 7         }
 8 
 9         ~ZLock(){
10             ::DeleteCriticalSection(&m_CS) ;
11         }
12 
13         void Lock()
14         {
15             ::EnterCriticalSection(&m_CS) ;
16         }
17 
18         void UnLock()
19         {
20             ::LeaveCriticalSection(&m_CS) ;
21         }
22     } ;
23 
24 
25     /// 自动锁
26     /*自动锁原理：利用类的构造函数，自动加锁，析构函数自动解锁*/
27     class ZAutoLock
28     {
29         ZLock* m_pLock ;
30     public:
31         ZAutoLock(ZLock* pLock)
32         {
33             m_pLock = pLock ;
34             m_pLock->Lock() ;
35         }
36 
37         ~ZAutoLock()
38         {
39             m_pLock->UnLock() ;
40         }
41     };

Fanze 2013-07-26 17:35 发表评论

  2     created:    2013/06/11
  3     created:    11:6:2013   19:11
  4     filename:     d:\HETU\Test\WIFetch\WIFetch\main.cpp
  5     file path:    d:\HETU\Test\WIFetch\WIFetch
  6     file base:    main
  7     file ext:    cpp
  8     author:        Fanze
  9     
 10     purpose:    从weather.com.cn抓取城市名称和代码信息
 11 *********************************************************************/
 12 
 13 #include <stdio.h>
 14 #include <stdlib.h>
 15 #include <Windows.h>
 16 #include <WinInet.h>
 17 #include <vector>
 18 #include "ZCharSetUtil.h"
 19 using namespace std ;
 20 
 21 #pragma comment(lib ,"Wininet")
 22 
 23 struct NCInfo
 24 {
 25     char Name[32] ;
 26     char Code[32] ;
 27 };
 28 
 29 typedef vector<NCInfo*> VTNCInfo ;
 30 typedef vector<NCInfo*>::iterator VTNCInfoIT ;
 31 
 32 struct SLInfo : public NCInfo
 33 {
 34     VTNCInfo VTCityInfo ;
 35 };
 36 typedef vector<SLInfo*> VTSLInfo ;
 37 typedef vector<SLInfo*>::iterator VTSLInfoIT ;
 38 
 39 enum TASK_DOWNRET
 40 {
 41     TASK_DOWN_OK = 0,
 42     TASK_DOWN_FAIL = 1,
 43     TASK_DOWN_CANCEL = 2,
 44 };
 45 
 46 const char* pStartToken = "line-content\">" ;
 47 const char* pEndToken = "</td>" ;
 48 
 49 const char* g_strXMLHeader = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n" ;
 50 const char* g_strRootTag = "<list>\r\n" ;
 51 
 52 const char* g_strCityListURL = "http://www.weather.com.cn/data/list3/" ;
 53 static char* g_strSLURL = "http://www.weather.com.cn/data/list3/city.xml?level=1" ;
 54 
 55 ///< 利用wininet下载文件
 56 static inline TASK_DOWNRET InetDownFile(const TCHAR* strSoureURL ,unsigned char* pResultBuf ,int nResultBufLen ,int* ResultLen)
 57 {
 58     HINTERNET hInternet ;
 59     HINTERNET hURLInternet ;
 60     BYTE Buf[2048] ={0} ;
 61     DWORD dwReads = 0 ;
 62     DWORD dwTotal = 0 ;
 63     int nSize = 0 ;
 64     TASK_DOWNRET Ret = TASK_DOWN_OK ;
 65 
 66     if(strSoureURL == NULL || pResultBuf == NULL || ResultLen == 0){
 67         return TASK_DOWN_FAIL ;
 68     }
 69 
 70     ///< 删除URL缓存，总是从服务器下载最新的文件。
 71     DeleteUrlCacheEntry(strSoureURL) ;
 72 
 73     hInternet = InternetOpen(NULL ,INTERNET_OPEN_TYPE_DIRECT ,
 74         NULL ,NULL ,0) ;
 75     if(hInternet == NULL){
 76         return TASK_DOWN_FAIL ;
 77     }
 78 
 79     hURLInternet = InternetOpenUrl(hInternet ,strSoureURL ,NULL ,0
 80         ,INTERNET_FLAG_EXISTING_CONNECT|INTERNET_FLAG_NO_CACHE_WRITE ,NULL) ;
 81     if(hURLInternet == NULL)
 82     {
 83         InternetCloseHandle(hInternet) ;
 84         DWORD dwErr = GetLastError() ;
 85         return TASK_DOWN_FAIL ;
 86     }
 87 
 88     while(InternetReadFile(hURLInternet ,Buf ,2048 ,&dwReads))
 89     {
 90         if(dwReads == 0){
 91             Ret = TASK_DOWN_OK ;
 92             break ;
 93         }
 94         nSize = ((dwTotal + dwReads) > (nResultBufLen - dwTotal)) ? (nResultBufLen - dwTotal) : dwReads ;
 95         memcpy(pResultBuf + dwTotal ,Buf ,dwReads) ;
 96         dwTotal += dwReads ;
 97     }
 98 
 99     *ResultLen = dwTotal ;
100 
101     InternetCloseHandle(hURLInternet) ;
102     InternetCloseHandle(hInternet) ;
103     return Ret ;
104 }
105 
106 void ParseItem(char* str ,NCInfo* pInfo)
107 {
108     char* pPos = str ;
109     char* pSave = NULL ;
110     char Temp[32] ={0} ;
111     if(str == NULL || pInfo == NULL)
112         return ;
113 
114     pSave = pInfo->Code ;
115     while(*pPos != '\0')
116     {
117         if(*pPos =='|')
118         {
119             pInfo->Code[pInfo->Code - pSave] ;
120             pSave = pInfo->Name ;
121         }else
122         {
123             *pSave = *pPos ;
124             pSave++ ;
125         }
126         pPos++ ;
127     }
128     UTF82ASCII(pInfo->Name ,Temp) ;
129     printf("Name:%s \r\n" ,Temp) ;
130     UTF82ASCII(pInfo->Code ,Temp) ;
131     printf("Code:%s \r\n" ,Temp) ;
132 }
133 
134 void Parse(char* str ,VTNCInfo* pVTInfo)
135 {
136     char* pPos = str ;
137     char Temp[32] ;
138     int nIndex = 0 ;
139     NCInfo* pInfo = NULL ;
140     while(*pPos != '\0')
141     {
142         if(*pPos == ',')
143         {
144             Temp[nIndex] = '\0' ;
145             ///< 解析一小段
146             pInfo = new NCInfo ;
147             memset(pInfo ,0 ,sizeof(NCInfo)) ;
148             ParseItem(Temp ,pInfo) ;
149             pVTInfo->push_back(pInfo) ;
150             nIndex = 0 ;
151         }else
152         {
153             Temp[nIndex] = *pPos ;
154             nIndex ++ ;
155         }
156         pPos++ ;
157     }
158     if(nIndex != 0)
159     {
160         Temp[nIndex] = '\0' ;
161         pInfo = new NCInfo ;
162         memset(pInfo ,0 ,sizeof(NCInfo)) ;
163         ParseItem(Temp ,pInfo) ;
164         pVTInfo->push_back(pInfo) ;
165     }
166 }
167 
168 void ProcReplyContent(char* pSrc ,char* pSaveBuffer)
169 {
170     char* pPos = NULL ;
171     char* pEndPos = NULL ;
172     pPos = strstr(pSrc ,pStartToken) ;
173     if(pPos == NULL)
174         return ;
175     pPos += strlen(pStartToken) ;
176     pEndPos = strstr(pPos ,pEndToken) ;
177     if(pEndPos == NULL)
178         return ;
179 
180     strncpy(pSaveBuffer ,pPos ,pEndPos - pPos) ;
181     pSaveBuffer[pEndPos - pPos] = '\0' ;
182 }
183 
184 ///< 解析省级代码，获取城市列表代码
185 void ParseSLCityInfo(SLInfo* pSLInfo ,VTNCInfo* pCityList)
186 {
187     char RequestURL[128] ={0} ;
188     char Buf[2048+1] ;
189     char Content[1024] ;
190     int nResultLen  = 0 ;
191     
192     if(pSLInfo == NULL || pCityList == NULL)
193     {
194         return  ;
195     }
196     ///< 生成请求URL
197     sprintf(RequestURL ,"%scity%s.xml?level=2" ,g_strCityListURL ,pSLInfo->Code) ;
198     if(InetDownFile(RequestURL ,(unsigned char*)Buf ,2048 ,&nResultLen) != TASK_DOWN_OK){
199         return ;
200     }
201     Buf[nResultLen] ='\0' ;
202     Parse(Buf ,pCityList) ;
203 }
204 
205 ///< 根据省一级的代码获取，所有城市列表
206 void ParseSLInfo(VTNCInfo* pVTSLList ,VTSLInfo* pVTSLInfoList)
207 {
208     VTNCInfoIT IT ;
209     SLInfo* pSLInfo = NULL ;
210     NCInfo* pNCInfo = NULL ;
211     int nIndex = 0 ;
212     
213     for(IT = pVTSLList->begin() ; IT != pVTSLList->end() ; IT++)
214     {
215         pNCInfo = *IT ;
216         if(pNCInfo == NULL)
217             continue ;
218 
219         pSLInfo = new SLInfo ;
220         strcpy(pSLInfo->Name ,pNCInfo->Name) ;
221         strcpy(pSLInfo->Code ,pNCInfo->Code) ;
222         Sleep(1000) ;
223         ParseSLCityInfo(pSLInfo ,&pSLInfo->VTCityInfo) ;
224 
225         pVTSLInfoList->push_back(pSLInfo) ;
226         nIndex ++ ;
227     }
228 }
229 
230 ///< 写入XML文件头
231 void WriteXMLHeader(FILE* fp)
232 {
233     fwrite(g_strXMLHeader ,1 ,strlen(g_strXMLHeader) ,fp) ;
234     fwrite(g_strRootTag ,1 ,strlen(g_strRootTag) ,fp) ;
235 }
236 
237 ///< 写入XML文件尾
238 void WriteXMLTail(FILE* fp)
239 {    
240     fprintf(fp ,"</list>\r\n") ;
241 }
242 
243 ///< 写入一个省、城市列表信息
244 void WriteXMLSLItem(FILE* fp ,SLInfo* pSLInfo)
245 {
246     VTNCInfoIT itt ;
247     NCInfo* pNCInfo = NULL ;
248     fprintf(fp ,"\t<sl>\r\n") ;
249     fprintf(fp ,"\t\t<name>%s</name>\r\n" ,pSLInfo->Name) ;
250     fprintf(fp ,"\t\t<code>%s</code>\r\n" ,pSLInfo->Code) ;
251     fprintf(fp ,"\t\t<city>\r\n") ;
252     for(itt = pSLInfo->VTCityInfo.begin() ; itt != pSLInfo->VTCityInfo.end() ; itt++)
253     {
254         pNCInfo = *itt ;
255         if(pNCInfo == NULL)
256             continue ;
257         fprintf(fp ,"\t\t\t<item name=\"%s\" code=\"%s\" />\r\n" ,pNCInfo->Name ,pNCInfo->Code) ;
258     }
259     fprintf(fp ,"\t\t</city>\r\n") ;
260     fprintf(fp ,"\t</sl>\r\n") ;
261 
262 }
263 
264 ///< 将结果保存至文件
265 void SaveToFile(char* strDstFile ,VTSLInfo* pSLInfoVT)
266 {
267     FILE* pSaveFile = NULL ;
268     VTSLInfoIT itt ;
269     SLInfo* pInfo = NULL ;
270     pSaveFile = fopen(strDstFile ,"wb+") ;
271     WriteXMLHeader(pSaveFile) ;
272     for(itt = pSLInfoVT->begin() ; itt != pSLInfoVT->end() ; itt++)
273     {
274         pInfo = *itt ;
275         if(pInfo == NULL)
276             continue ;
277         WriteXMLSLItem(pSaveFile ,pInfo) ;
278     }
279     WriteXMLTail(pSaveFile) ;
280     fclose(pSaveFile) ;
281 }
282 
283 void FreeNCVt(VTNCInfo* pVTInfo)
284 {
285     VTNCInfoIT it ;
286     NCInfo* pInfo = NULL ;
287     for(it = pVTInfo->begin() ; it != pVTInfo->end() ; it++)
288     {
289         pInfo = *it ;
290         if(pInfo != NULL)
291         {
292             delete pInfo ;
293         }
294     }
295     pVTInfo->clear() ;
296 }
297 
298 int main()
299 {
300     FILE* fp = NULL ;
301     char strSLFile[128] ;
302     char *pBuffer = new char[1024*4+1] ;
303     int nReadLen = 0 ;
304     VTNCInfo VTInfo ;
305     VTSLInfo VSLInfo ;
306 
307     if(InetDownFile(g_strSLURL ,(unsigned char*)pBuffer ,1024*4 ,&nReadLen) != TASK_DOWN_OK){
308         printf("下载省级列表失败 \r\n") ;
309         return 1 ;
310     }
311     pBuffer[nReadLen] = '\0' ;
312 
313     ///< 解析省级城市和代码
314     Parse(pBuffer ,&VTInfo) ;
315 
316     ///< 开始处理省级文件
317     ParseSLInfo(&VTInfo ,&VSLInfo) ;
318 
319     ///< 写入文件
320     printf("开始将文件存入c:\\CityList.xml\r\n") ;
321     SaveToFile("c:\\CityList.xml" ,&VSLInfo) ;
322     delete[] pBuffer ;
323 
324     VTSLInfoIT it ;
325     SLInfo* pSLInfo = NULL ;
326     for(it = VSLInfo.begin() ; it != VSLInfo.end() ; it ++)
327     {
328         pSLInfo = *it ;
329         if(pSLInfo == NULL)
330             continue ;
331         FreeNCVt(&pSLInfo->VTCityInfo) ;
332         delete pSLInfo ;
333     }
334 
335     FreeNCVt(&VTInfo) ;
336 
337     printf("所有处理已完成，按任意键结束。") ;
338     getchar() ;
339     return 0 ;
340 }

Fanze 2013-06-11 19:33 发表评论

CActiveXUI                    showactivex         创建完成后，显示时通知。

CCombUI                       itemselect            调用SelectItem选择改变时通知。

CCombUI                       dropdown            调用Activate时通知。

CButtonUI                      menu                   当按钮的事件类型为，VIEWENT_CONTEXTMENU即上下文菜单时通知。

CButtonUI                      click                     按钮激活时通知。

COptonUI                      selectchanged                 当调用Selected，选择项更改后通知。

CTextUI                          link                       暂未知

CliderUI                         valuechanged             当鼠标按钮弹起时通知。

CEditWnd                      return                  当按下回车按键后通知。

CEditWnd                      textchanged                  当文本改变时通知。

CScrollbarUI                  scroll                    当双击或单击滚动条时通知。

CControlUI                    timer                    定时器触发通知。

CControlUI                    menu                   上下文菜单通知。

CListUI                           itemselect           当选择更改时通知。

CListUI                           headerclick         当单击列表的头(column header)时通知。

CListUI                           itemactivate       当某一项激活时，通知。

CListUI                                           itemclick               当单击某一项时通知。

CListTextElementUI                      link                        未知。

CListContainerElementUI            itemactivate          激活事件。

CListContainerElementUI            itemclick                当单击左键或右键时通知。

CPaintManagerUI                         windowinit            WM_PAINT消息响应时，若为第一个布局，则通知。

CPaintManagerUI                        killfocus                  (设置焦点时，若设置的控件指针为空，则不再是焦点窗口)失去焦点时通知。

CPaintManagerUI                        setfocus                  设置焦点时通知。

CRitchEditUI                                 return                     输入回车键时通知。

Fanze 2013-01-08 19:19 发表评论

MIB_IFROW  中有一项 dwOperStatus的参数，它表明当前接口的操作状态

其值如下：

Value Meaning

IF_OPER_STATUS_NON_OPERATIONAL

LAN adapter has been disabled, for example because of an address conflict. 

局域网适配器禁用，例如地址冲突

IF_OPER_STATUS_UNREACHABLE

WAN adapter that is not connected.

WAN适配器未连接

IF_OPER_STATUS_DISCONNECTED

For LAN adapters: network cable disconnected. For WAN adapters: no carrier

局域网适配器：网线未插入。WAN适配器：无信号

IF_OPER_STATUS_CONNECTING

IF_OPER_STATUS_CONNECTED 

WAN adapter that is connected to a remote peer.

 已连接远端

IF_OPER_STATUS_OPERATIONAL

参考：ms-help://MS.VSCC.v90/MS.MSDNQTR.v90.chs/iphlp/iphlp/getifentry.htm

  

经测试

拔下网线时，dwOperStatus 值为IF_OPER_STATUS_NON_OPERATIONAL 

连接网线时，dwOperStatus 值为IF_OPER_STATUS_OPERATIONAL

Fanze 2013-01-02 17:39 发表评论

============================================================================

HLSL : High Level Shader Language 译为：高级着色语言

HLSL语言的语法类似于C语言

1. 数据类型

HLSL中的数据类型有：标准数据类型、向量、矩阵和复杂数据类型。

———|———————————————————————————————————|

类型                            取值

———|———————————————————————————————————|

———|———————————————————————————————————|

1.1 变量声明

常规声明    float fVar ;

声明时初始化    float fVar = 1.0f ;

数组声明 int iVar[3] = {1 ,2 ,3} ;    // 声明一个大小为3的整型数组,并初始化为1 ，2，3.

1.2 类型修饰符

(1) const  常量 其值不可改

此类型修饰符表明一个变量的数值不可被渲染代码修改。例如：

    const float fConstant = 2.0f ;

同C语言一样，其声明时徐初始化。

1.3 row_major与col_major

这一对修饰符出现在定义一个矩阵时。将其放在矩阵之前，例如：

    row_major float 4x4 WorldMatrix ;

其作用在于指定当前定义的矩阵中的元素，使用行主序还是列主序进行存放（矩阵的行列式）。

示例：

    col_major      11    12    13    14

                           21    22    23    24

                           31    32    33    34

                           41    42    43    44

    row_major    11    21    31    41

                          12    22    32    42

                          13    23    33    43

                          14    24    34    44

行或者列主序决定了从常量表或从渲染器输入中读取矩阵元素的顺序。

1.4 寄存器类型修饰符

寄存器类型修饰符用于高速编译器变量的作用域和生命期

(1) static

static float fVale = 1.11f ;

具全局作用。Static关键字防止渲染器变量暴露给应用程序。

同C语言一样，在函数内部的变量，其值保存到下一次调用。

(2) extern

extern float4 fExternal ;

与Static相反。其义同C语言关键字。

(3) uniform

uniform float fUniforVal = 3.0f ;

只可使用API方法改变它，且只在两次绘制间改变。

(4) shared

shared修饰全局Shader变量表明它在不同的效果中被共享。

shared float fSharedVal ;

2 向量

(1) 向量类型是一种特殊的数据结构，一个向量可能包含1-4个元素。例如：

   
    注意：数据类型后跟的数字，表明向量的维度。

   
    声明1

    bool bVector ;    标量 1个bool型数据

    bool1 bVector ;    向量，包含一个bool变量

    int1 iVector ;         向量，包含一个int变量

    half2 hVector ;      向量，包含两个half变量

    float3 fVector ;     向量，包含三个float变量

    double4 fVector ; 向量，包含四个double变量

    变量声明初始化可以同时进行

    bool1    bVector = FALSE ;

    int1        iVector = 1 ;

    half2      hVector = {0.2 ,0.3} ;

    float3    fVector = {0.3f ,0.4f ,0.5f} ;

    double4      dVector = {0.2 ,0.3 ,0.4 ,0.5} ;

    
   声明2

    当声明向量时，可以在一个尖括号中指定该向量的类型和向量中的元素个数。

    vector<bool ,1> bVector = TRUE  ;

    vector<int ,1> iVector = 1 ;

    vector<half ,2> hVector = {0.2 ,0.3 } ;

    vector<float ,3> fVector = {1.0f ,2.0f ,3.0f} ;

    vector<double ,4> dVector = {1.0 ,2.0 ,3.0 ,4.0} ;

 (2)向量元素的存取

    一个向量最多包含4个元素。可使用位置x、y、z、w和颜色r、g、b、a进行寻址。

    float4 Pos = float4{0.0f ,1.0f ,2.0f ,3.0f} ;

    对于向量Pos，使用Pos.z和Pos.b都返回第三个元素，即2.0f。

    在一次存取过程中，可以使用一个命名集合获取一个或多个元素，但命名集合不能混用。

    如：

    float4 Pos = float4(1.0f ,2.0f ,3.0f ,4.0f) ;

    float2 Temp ;

    Temp = Pos.xy ; // 正确 x y命名相同

    Temp = Pos.rg ; // 正确 r g命名相同
    Temp = Pos.xb ; // 错误x b命名混用

(3)向量元素的混合存取

    将读取一个或多个指定的向量元素，称之为混合存取(swizzling).

    存取示例：

    float4 pos = float4(0 , 0 , 2 ,1) ;

    float2 f_2D ;

    f_2D = pos.xy ; // 读取两个元素x和y，并赋值给f_2D

    f_2D = pos.xz ; // 读取pos的x和z，赋值给f_2D,可以以任何顺序读取元素

    f_2D = pos.zx ; // 元素可逆序读取

    f_2D = pos.xx ; // 重复读取，元素可以多次读取

    f_2D = pos.yy ; // 同上

    赋值操作

    float4 pos = float4(0 ,0 ,2 ,1) ;

    float4 f_4D ;

    f_4D = pos ; // 相当于f_4D.x = pos.x ; f_4D.y = pos.y ; f_4D.z = pos.z ;f_4D.w = pos.w ;

    f_4D.xz = pos.xz ; // 等同于f_4D.x = pos.x ; f_4D.z = pos.z ;

    f_4D.zx = pos.xz ; // 等同于f_4D.z = pos.x ; f_4D.x = pos.z ;

    f_4D.xyzw = pos.w ;// 等同于f_4D.x = pos.w ; f_4D.y = pos.y ;f_4D.z = pos.z ;

    f_4D.wzyx = pos ; //等同于 f_4D.w = pos.x ; f_4D.z = pos.y ;f_4D.y = pos.z ; f_4D.x = pos.x ;

    以下语句无效

    f_4D.xx = pos.xy ;

    f_4D.xg = pos.rg ;

(4)向量的数学运算

    乘法符号为“*“

    假设a ,b都为float4类型

    float4 v = a * b ;

    可视为：

    v.x = a.x * b.x ;

    v.y = a.y * b.y ;

    v.z = a.z * b.z ;

    v.w = a.w * b.w ;

    此为点乘

3 矩阵

    (1)

    矩阵是一种以行和列将数据组织起来的数据结构。

    矩阵数据类型后紧跟x指明该矩阵的行和列。例如：

    int1x1    iMatrix        整形矩阵，1行1列

    int2x1    iMatrix        整形矩阵，2行1列

    int4x1    iMatrix        整形矩阵，4行1列

    int1x4    iMatrix        整形矩阵，1行4列

    double1x1    dMatrix        double型矩阵，1行1列

    double2x2    dMatrix        double型矩阵，2行2列

    double3x3    dMatrix        double型矩阵，3行3列

    double4x4    dMatrix        double型矩阵，4行4列

    HLSL中矩阵的行和列数最大为4，最小为1

    

    矩阵的声明和初始化

    float2x2    fMatrix ={0.0f ,0.1f ,       // 第一行

                                        2.1f ,2.2f} ;    // 第二行

    

    matrix <float ,2 ,2> fMatrix ={0.0f ,0.1         // 第一行

                                                        2.1f ,2.2f } ;    // 第二行

    使用关键字matrix声明。这是一个矩阵，其类型为float，行数和列数都为2。

   
    (2) 矩阵元素的存取

    矩阵时以行和列将数据组织起来的，可以通过结构体操作符"."来存取其中的数据。

    存取方法有两种

    两种方法中，每个元素的标识都是以下划线开始的，后跟行号和列号。

    0基准位置法中，行号和列号前还有一个字母m。

    访问示例：

    float2x2    fMatrix ={1.0f ,1.1f ,2.0f ,2.1f} ;

    float    f_1D ;

    f_1D = fMatrix._m00 ;        // 取行1、列1数据    1.0f 

    f_1D = fMatrix._m11 ;        // 取行2、列2数据    2.1f

    f_1D = fMatrix._11  ;           // 取行1、列1数据    1.0f

    f_1D = fMatrix._22 ;            // 取行2,、列2数据    2.1f

    访问矩阵多个元素

    float2x2    fMatrix ={1.0f ,1.1f ,2.0f ,2.1f} ;

    float    temp ;

    temp = fMatrix._m00_m11 ;

    temp = fMatrix._m11_m00 ;

    temp = fMatrix._11_22 ;

    temp = fMatrix._22_11 ;

   
   (3) 矩阵的混合存取

    与向量类似，对矩阵一个以上的元素进行读取或复制操作，称为混合存取(swizzling)。

    float4x4    worldMatrix=    float4({0 ,0 ,0 ,0} ,{1 ,1 ,1 ,1} ,{2 ,2 ,2 ,2} ,{3 ,3 ,3 ,3}) ;

    float4x4    tempMatrix ;

    tempMatrix._m00_m11 = worldMatrix._m00_m11 ;

    tempMatrix._m00_m11 = worldMatrix._m13_m33 ;

    tempMatrix._11_22_33 = worldMatrix._11_22_33 ;

    tempMatrix._11_22_33 = worldMatrix._24_23_22 ;

    

    不正确的赋值

    tempMatrix._11_m23 = worldMatrix._11_12 ;    //  两种基准方式混用    

    tempMatrix._m00_m00 = worldMatrix.m_00_m11 ;    // 不可在一次赋值对一个元素进行两次赋值

   
   (4) 矩阵的数组存取方式

    矩阵也可以使用类似访问数组的方式对其进行访问，此时基准为0，不是1.

    4X4矩阵，可通过如下索引来访问其中的每个元素

        [0][0],    [0][1] ,    [0][2],    [0][3]

        [1][0],    [1][1],     [1][2],    [1][3]   

        [2][0],    [2][1],     [2][2],    [2][3],

        [3][0],    [3][1],     [3][2],    [3][3], 

    

    赋值

    float2x2    fMatrix ={1.0f ,1.1.f ,2.0f ,2.1f} ;

    float    temp ;

    temp = fMatrix[0][0] ;

    temp = fMatrix[0][1] ;

    

    数组存取方式可以用来存取多元素的向量

    float2    temp ;

    float2x2    fMatrix ;

    temp = fMatrix[0] ;    // 将矩阵fMatrix的第一行赋值给向量temp

   
    (5) 矩阵的存放顺序

    矩阵中数据的存放方式具体采用行主序还是列主序可以在编译的指定。

    使用语句 #pragma pack_matrix(row_major) 或 #pragma pack_matrix(col_major)指定。

    列主序效率高于行主序

   
    (6) 矩阵的数学运算

    HLSL中，矩阵的数学原酸也是逐元素进行的

    float3x3 mat1 ,mat2 ；

    float3x3 mat3 = mat1 * mat2 ;

    其结果mat3中的值，是两个矩阵mat1和mat2的元素逐个进行相乘后的值

    mat3.m00 = mat1._m00 * mat._m00 ;

 
    (7) 复杂数据类型

    HLSL支持复杂的数据类型来处理类似采样器(sampler)、结构体(structure)、渲染器(shader)这样的对象

    采样器

 

Fanze 2013-01-02 17:34 发表评论

如：

#define Q(TEXT) "a"##TEXT

示例代码：

注：示例代码在VC2008中测试通过

注2：GCC中测试未通过

Fanze 2013-01-02 17:32 发表评论