memo

folklore

Basic 3D Math: Matrices
Matrices are rectangular mathematical objects which have a number of rows and columns – think of it as a two-dimensional array. Take a look at the following:Above is a 3×4 Matrix (because it has 3 rows and 4 columns) – speak: 3 by 4 Matrix. Each element of the Matrix can be indexed by using the following notation: where i is the row and j the column: because the element at the 3rd rows and 2nd column has the value 10.Matrices are used in CG to represent a various number of different things like transformations and orientations.Part 1: Multiplying Matrices (Matrix Product)Matrix multiplication is not commutative, which means that the order of operation is relevant (as opposed to the multiplication of real numbers). In order to be able to multiply two matrices they must satisfy the rule that column of the first must match the rows of the second. Take a look at the following graphic which works as a simple reminder for the rules of matrix multiplication:But what’s the purpose of multiplying matrices? In 3D Programming you do Transforming a vertex with such a operation. Stop – how can i multiply a vector (which stores a vertex position) with a matrix? Vectors can be thought as Vectors with 1 Row and 4 Columns – and because multiplying a 1×4 Matrix with a 4×4 Matrix is a valid operation this works.In the first step, lets examine how to actually do the multiplication – formally this looks like:i = row index
j = column index
p = number of columns of the first matrix (or number of rows of the second one)Because a example often says more than thousand words, take a look at the following:We have two matrices: and . Multiplication of those two is possible because the number of columns of A matches the number of rows of B – the result is a 2×2 Matrix.Let’s perform the Calculation step by step.Step 1: Write down the calculation of every index for the resulting matrix
Step 2: Do the calculations
results in:Part 2: Creating Matrices for TransformationsAs mentioned above at the beginning of this document, matrices can be used to transform vectors. Its obvious that you need corresponding matrices which represent the transformation, so they are presented below – please note that they are for OpenGL only (The “why” is discussed at the end)Identity Matrix:The Identity matrix can be seen as the “reset” state matrix. If you multiply a vector with the Identity matrix you get the original vector. You initialise new matrices to the identity.Translation Matrix:X, Y and Z represent the amount you want to translate the vector on the axis.Scaling Matrix:X,Y and Z represent the amount of scaling on the corresponding axis.Rotation Matrix:There are four rotation matrices – one about each Axis (X,Y and Z) and one for rotating about an arbitrary axe. is the roation in radians.    The matrix used to rotate about an arbitrary axis is a little bit more complicated.Assumptations: Then the matrix looks like:The Vector (x,y,z) which represents the rotation axis must be normalizedMost of the time you don’t need to create those matrices by ourself because either the math library you are using provides them or you write your own.Part 3: Order of operation and combining transformationsThe order of multiplying multiple transformation matrices is cruical. In OpenGL you get the final transformation by reading your statement from left to right. Example:R is a rotation, T a translation matrix. The Vector V is first Translated and then rotated. Take a look at the pictures below to see the difference visually:In this Picture, the vertices of the Object are first multiplied by a rotation matrix (about Z) – which rotates the local object coordinates. After that a translation matrix (move along X)  is applied, so the object moves along the rotated X axis. The order of the multiplications are:As mentioned before, we read from right to left (Take Vector V, then Rotate, then Translate)This time we first multiply with a translation matrix (translate along X) and then apply a rotation matrix:Which means: Take Vector V, then translate, then rotate.Please note that the order only applies to OpenGL. In DirectX it’s from left to right – also the matrices are a little bit different in how they look like.Part 4: Going aheadMost OpenGL based 3D Libraries and Toolkits provide easy ways of creating the matrices mentioned above (i REALLY like Richard Wright’s Math3D Library which he uses in his Book OpenGL Superbible).If you want to dig deeper into the mathematics behind 3D Graphics, i highly recommend you the following two books:

• Mathematics fro Computer Graphics
• 3D Math Primer for Graphics and Game Development
  

folklore

回复 2# bruceteen


    我不想自已推导，所以做了个Memo，没想一上来就被你取笑。。
星星最近如何，转Linux了么？

folklore

回复 7# bruceteen


    哪里深奥了。用高中的数学就能推出来吧。只是俺比较懒。。。。
现在在做一个CAD/CAM系统。各种苦B。

folklore

1. static void Matrix3dMultiple(double rt[4][4],double multiplicand[4][4],double multiplicate[4][4]){
   
2.         double rs[4][4];
   
3.        
   
4.         for(int iY =0;iY<_countof(rs);iY++){
   
5.                 for(int iX =0;iX<_countof(rs[0]);iX++){
   
6.                         rs[iY][iX] =0.0L;
   
7.                         for(int iAdd=0;iAdd <_countof(multiplicand[0]);iAdd++){
   
8.                                 rs[iY][iX] +=multiplicand[iY][iAdd] *multiplicate[iAdd][iX];
   
9.                         }
   
10.                 }
    
11.         }
    
12. 
    
13.         memcpy(rt,rs,sizeof(rs));
    
14. }// end function: Matrix3dMultiple

复制代码

folklore

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <windows.h>
   
4. #include <vector>
   
5. #include <sstream>
   
6. 
   
7. #pragma comment(lib,"User32.lib")
   
8. #pragma message("Compiling command(dll): cl.exe /EHsc /Ot /Ox /W4 /LD /DDLL "__FILE__" /link /subsystem:console")
   
9. #pragma message("Compiling command(exe): cl.exe /EHsc /Ot /Ox /W4 "__FILE__" /link /subsystem:console")
   
10. 
    
11. // -- Html Helper function
    
12. static std::wstring HtmlEncode(const std::wstring& html){
    
13.         std::wostringstream result;
    
14.         for (std::wstring::const_iterator itCh = html.begin(); itCh !=html.end(); itCh++){
    
15.                 switch(*itCh){
    
16.                         case L'<':
    
17.                                 result <<L"&lt;";
    
18.                                 break;
    
19.                         case L'>':
    
20.                                 result <<L"&gt;";
    
21.                                 break;
    
22.                         case L'&':
    
23.                                 result <<L"&amp;";
    
24.                                 break;
    
25.                         case L'\"':
    
26.                                 result <<L"&quot;";
    
27.                                 break;
    
28.                         default:
    
29.                                 result <<static_cast<wchar_t>(*itCh);
    
30.                                 break;
    
31.                 }
    
32.         }
    
33.         return result.str();
    
34. }
    
35. //static std::wstring HtmlDecode(const std::wstring& html)
    
36. //{
    
37. //        std::wostringstream result;
    
38. //        size_t iParse =0;
    
39. //        while(iParse <html.length()){
    
40. //                if(html.at(iParse) !=L'&'){
    
41. //                        result <<html.at(iParse++);
    
42. //                }else{// enter slash staus
    
43. //                        std::wostringstream enctext;
    
44. //                        while(html.length() >iParse &&html.at(iParse) !=L';'){
    
45. //                                enctext <<html.at(iParse++);
    
46. //                        }
    
47. //                        if(_wcsicmp(enctext.str().c_str(),L"&lt") ==0){
    
48. //                                result <<L'<';
    
49. //                        }else if(_wcsicmp(enctext.str().c_str(),L"&gt") ==0){
    
50. //                                result <<L'>';
    
51. //                        }else if(_wcsicmp(enctext.str().c_str(),L"&amp") ==0){
    
52. //                                result <<L'&';
    
53. //                        }else if(_wcsicmp(enctext.str().c_str(),L"&quot") ==0){
    
54. //                                result <<L'\"';
    
55. //                        }
    
56. //                        if(html.length() >iParse) iParse++;        // Skip semicolon
    
57. //                }
    
58. //        }
    
59. //        return result.str();
    
60. //}// end function: HtmlDecode
    
61. // -- end: Html helper functions
    
62. 
    
63. struct IOS{
    
64.         std::wstring Input;
    
65.         std::vector<HWND> Output;
    
66. };
    
67. /// <summary>
    
68. ///                Walk through all windows&subwindows that shown in current desktop, and figure out the window which be identified with special UUID prop
    
69. ///        </summary>
    
70. /// <see>
    
71. ///                See msdn to get more info aboud this function (Relative API "EnumWindows"/"EnumChildWindows")
    
72. ///        </see>
    
73. static BOOL CALLBACK EnumWindowsProc(_In_ HWND hwnd,_In_ LPARAM lParam){
    
74.         struct IOS *pIos =(struct IOS *)lParam;
    
75. 
    
76.         HANDLE hData =::GetPropW(hwnd,pIos->Input.c_str());
    
77.         if(hData !=NULL){
    
78.                 pIos->Output.push_back(hwnd);
    
79.                 EnumChildWindows(hwnd,EnumWindowsProc,lParam);
    
80.         }
    
81.         return TRUE;
    
82. }// end function: EnumWindowsProc
    
83. 
    
84. // -- local helper function
    
85. static std::wstring _Makeparams(const wchar_t *const pParams){
    
86.         std::wstring rsMsg;
    
87.         rsMsg.append(L"\t\t\t<Params>\n");
    
88.         const wchar_t *pParam =pParams;
    
89.         do{
    
90.                 rsMsg.append(L"\t\t\t\t<Param>");
    
91.                 rsMsg.append(HtmlEncode(pParam));
    
92.                 rsMsg.append(L"</Param>\n");
    
93.                 while(pParam[0] !=NULL){
    
94.                         pParam++;
    
95.                 }// end if
    
96.                 pParam++;
    
97.         }while(pParam[0] !=NULL);
    
98.         rsMsg.append(L"\t\t\t</Params>\n");
    
99.         return rsMsg;
    
100. }
     
101. /// <summary>
     
102. ///                MakeMessage: Input the message and translate it to XML format
     
103. /// </summary>
     
104. // The result string looks like
     
105. // <messages>
     
106. //        <message ext-code="3">
     
107. //                <Title code="35" Description="">
     
108. //                        <Params>
     
109. //                                <Param>p1 of content<Param>
     
110. //                        <Params>
     
111. //                </Title>
     
112. //                <Content code="53" Description="">
     
113. //                        <Params>
     
114. //                                <Param>p1 of content</Param>
     
115. //                        <Params>
     
116. //                </Content>
     
117. //        </message>
     
118. // </messages>
     
119. static std::wstring MakeMessage(const wchar_t *const id,const long cdTitle,const wchar_t *const pTitle,const long cdBody,const wchar_t *const pBody,const wchar_t *const paramsTitle=NULL,const wchar_t *const paramsContent=NULL,const long cdExtend=-1){
     
120.         (void) id;
     
121.         wchar_t intbuf[MAX_PATH];        // Global buffer
     
122. 
     
123.         // -- Xml header
     
124.         std::wstring rsMsg(L"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
     
125.         rsMsg.append(L"<Messages>\n");
     
126.         rsMsg.append(L"\t<Message ext-code=\"");
     
127.         _itow_s(cdExtend,intbuf,MAX_PATH,10);
     
128.         rsMsg.append(intbuf);
     
129.         rsMsg.append(L"\"");
     
130.         // -- UUID if specified
     
131.         if(id !=NULL){
     
132.                 rsMsg.append(L" UUID=\"");rsMsg.append(HtmlEncode(id));rsMsg.append(L"\"");
     
133.         }//end if
     
134.         rsMsg.append(L">\n");
     
135.         // -- Title
     
136.         _itow_s(cdTitle,intbuf,MAX_PATH,10);
     
137.         rsMsg.append(L"\t\t<Title code=\"");rsMsg.append(intbuf);rsMsg.append(L"\"");
     
138.         if(pTitle !=NULL){
     
139.                 rsMsg.append(L" Description=\"");rsMsg.append(HtmlEncode(pTitle));rsMsg.append(L"\"");       
     
140.         }
     
141. 
     
142.         if(paramsTitle !=NULL){
     
143.                 rsMsg.append(L">\n");
     
144.                 rsMsg.append(_Makeparams(paramsTitle).c_str());
     
145.                 rsMsg.append(L"\t\t</Title>\n");
     
146.         }else{
     
147.                 rsMsg.append(L"/>\n");
     
148.         }
     
149. 
     
150.         // -- Content
     
151.         _itow_s(cdBody,intbuf,MAX_PATH,10);
     
152.         rsMsg.append(L"\t\t<Content code=\"");rsMsg.append(intbuf);rsMsg.append(L"\"");
     
153.         if(pBody !=NULL){
     
154.                 rsMsg.append(L" Description=\"");rsMsg.append(HtmlEncode(pBody));rsMsg.append(L"\"");
     
155.         }
     
156.         if(paramsContent !=NULL){
     
157.                 rsMsg.append(L">\n");
     
158.                 rsMsg.append(_Makeparams(paramsContent).c_str());
     
159.                 rsMsg.append(L"\t\t</Content>\n");
     
160.         }else{
     
161.                 rsMsg.append(L"/>\n");
     
162.         }
     
163. 
     
164.         rsMsg.append(L"\t</Message>\n");
     
165.         rsMsg.append(L"</Messages>");
     
166.         return rsMsg;
     
167. }// end function: MakeMessage
     
168. 
     
169. /// <summary>
     
170. ///                Send message to UI (typically main window) program that registered. The COM component can be executed in remote host.
     
171. ///                This function try to send message to *local host* (and typically the local host show a message depend on the message-code).
     
172. /// </summary>
     
173. /// <param name="pUUIDDes">UUID of target window (via get/setprop)</param>
     
174. /// <param name="id">The message id, can be null</param>
     
175. /// <param name="cdTitle">Code of message title</param>
     
176. /// <param name="pTitle">Message title, can be null</param>
     
177. /// <param name="cdBody">Code of message body</param>
     
178. /// <param name="pBody">Message content, can be null</param>
     
179. /// <Return> The number of the target window </Return>
     
180. extern "C" __declspec(dllexport) int SendUIMessage(const wchar_t *const pUUIDDes,wchar_t *const id,const long cdTitle,const wchar_t *const pTitle,const long cdBody,const wchar_t *const pBody,const wchar_t *const paramsTitle=NULL,const wchar_t *const paramsContent=NULL,const long cdExtend=0){
     
181.         int nSent =0;
     
182.         if(pUUIDDes !=NULL){
     
183.                 struct IOS ios;
     
184.                 ios.Input =pUUIDDes;
     
185. 
     
186.                 ::EnumWindows(EnumWindowsProc,(LPARAM)&ios);
     
187.                 for(std::vector<HWND>::iterator itHwnd =ios.Output.begin(); itHwnd !=ios.Output.end();itHwnd++){
     
188.                         std::wstring msgstr =MakeMessage(id,cdTitle,pTitle,cdBody,pBody,paramsTitle,paramsContent,cdExtend);
     
189.                         COPYDATASTRUCT msg ={
     
190.                                 NULL,(msgstr.size()+1)<<1,(LPVOID)msgstr.c_str()
     
191.                         };
     
192.                         ::SendMessage(*itHwnd,WM_COPYDATA,NULL,(LPARAM)&msg);
     
193.                         //MessageBoxW(*itHwnd,L"OK",L"OK",MB_OK);        // -- Try to show message at destinate window
     
194.                         nSent++;
     
195.                 }
     
196.         }// end if
     
197.         return nSent;
     
198. }
     
199. 
     
200. #if !defined(DLL)
     
201. static const wchar_t *const UUIDBendCAM =L"{3B0C708E-8014-4f33-BFC8-4AE1E8F3901C}";
     
202. static size_t dntwcslen(const wchar_t *const pSrc){        //double null terminal string
     
203.         size_t rsSize =0;
     
204.         if(pSrc !=NULL){
     
205.                 do{
     
206.                         while(pSrc[rsSize] !=NULL){rsSize++;}
     
207.                         rsSize++;
     
208.                 }while(pSrc[rsSize] !=NULL);
     
209.         }
     
210.         return rsSize;
     
211. }
     
212. int main(void){
     
213.         const wchar_t *const pParams =L"Param<01>\0Param02\0";
     
214.         std::wstring params;
     
215.         params.resize(dntwcslen(pParams));
     
216.         for(size_t iAssign =0;iAssign <params.size();iAssign++){        // the size is not include the last terminal tocken
     
217.                 params.at(iAssign) =pParams[iAssign];
     
218.                 //wprintf(L"%c",params.at(iAssign));
     
219.         }
     
220.         //wprintf(L"\n%d",dntwcslen(pParams));
     
221.         if(0 ==SendUIMessage(UUIDBendCAM,NULL,123,L"Title&b",456,L"Context: <happy new year.>",params.data(),params.data())){
     
222.                 std::wstring msg=MakeMessage(NULL,123,L"Title&b",456,L"Context: <happy new year.>",params.data()/*,params.data()*/);
     
223.                 wprintf(L"%s",msg.c_str());
     
224.         }
     
225.         return 0;
     
226. }
     
227. #endif //!defined(DLL)

复制代码

new version

folklore

回复 10# linux_c_py_php


    以前一直以为程序和数学是不分家的。直到有一天，有个电信公司叫我写无聊的电信业务系统。

folklore

The following issue explain you how to apply the metries to an 3d vertex.

In order to apply a general 4x4 transformation matrix to a vertex represented as a 3 dimensional vector, you need to:
1.Expand the vector into the 4th dimension by adding a 1 as the W component:
        (x, y, z) => (x, y, z, 1)
2.Multiply the transformation matrix by the 4 dimensional vector above. The result will be another 4 dimensional vector:
        ( 4x4 matrix ) * (x, y, z, 1) => (tx, ty, tz, w)
The general formula for multiplying a 4x4 matrix by a 4x1 vector is (if I didn't mess up):
        [ m11 m12 m13 m14 ][ x ]   [ m11 * x + m12 * y + m13 * z + m14 * w ]
        [ m21 m22 m23 m24 ][ y ]   [ m21 * x + m22 * y + m23 * z + m24 * w ]
        [ m31 m32 m33 m34 ][ z ] = [ m31 * x + m32 * y + m33 * z + m34 * w ]
        [ m41 m42 m43 m44 ][ w ]   [ m41 * x + m42 * y + m43 * z + m44 * w ]
Or if you consider the usual configuration of a transformation matrix:
        [ m11 m12 m13 px ][ x ]   [ m11 * x + m12 * y + m13 * z + px ]
        [ m21 m22 m23 py ][ y ]   [ m21 * x + m22 * y + m23 * z + py ]
        [ m31 m32 m33 pz ][ z ] = [ m31 * x + m32 * y + m33 * z + pz ]
        [ 0   0   0   1  ][ 1 ]   [ 1 ]
3.Convert it back into the 3rd dimension by homogenizing the vector, i.e. dividing everything by the fourth component w:
        (tx, ty, tz, w) => (tx/w, tx/w, tz/w)

The thing is that if your transformation matrix only does a simple translation / rotation / scale, the value of w will be 1 and you can just drop the fourth component since that will be the same as dividing by 1.
But it's good to remember that it does not work for every case, e.g. with projection matrices you must remember to do this third step.

folklore

XSL文件真蛋疼， 麻烦死了， 写个函数：

1. 
   
2. ///<summary>
   
3. ///  Indent format file
   
4. ///</summary>
   
5. ///<param name ="pXmlDoc">Source xml document object</param>
   
6. ///<return>formated xml document object</return>
   
7. static MSXML2::IXMLDOMDocumentPtr ApplyXmlIndent(MSXML2::IXMLDOMDocumentPtr pXmlDoc){
   
8.         static const wchar_t *const XmlStyleSpecString =
   
9.                 L"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
   
10.                 L"<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n"
    
11.                 L"        <xsl:output method=\"xml\" indent=\"yes\"/>\n"
    
12.                 L"        <xsl:template match=\"@* | node()\">\n"
    
13.                 L"                <xsl:choose>\n"
    
14.                 L"                        <xsl:when test=\"not(node()) and not(text())\">\n"
    
15.                 L"                                <xsl:copy>\n"
    
16.                 L"                                        <xsl:apply-templates select=\"@*\"/>\n"
    
17.                 L"                                </xsl:copy>\n"
    
18.                 L"                        </xsl:when>\n"
    
19.                 L"                        <xsl:otherwise>\n"
    
20.                 L"                                <xsl:copy>\n"
    
21.                 L"                                        <xsl:apply-templates select=\"@* | node()\"/>\n"
    
22.                 L"                                </xsl:copy>\n"
    
23.                 L"                        </xsl:otherwise>\n"
    
24.                 L"                </xsl:choose>\n"
    
25.                 L"        </xsl:template>\n"
    
26.                 L"</xsl:stylesheet>";
    
27. 
    
28.         //Create the final document which will be indented properly
    
29.         MSXML2::IXMLDOMDocumentPtr pXMLFormattedDoc(__uuidof(MSXML2::DOMDocument)),fmtXml(__uuidof(MSXML2::DOMDocument));
    
30. 
    
31.         do{
    
32.                 if(fmtXml->loadXML(_bstr_t(XmlStyleSpecString)) ==VARIANT_FALSE){
    
33.                         break;
    
34.                 }
    
35. 
    
36.                 IDispatchPtr pDispatch;
    
37.                 HRESULT hr = pXMLFormattedDoc->QueryInterface(IID_IDispatch, (void**)&pDispatch);
    
38.                 if(FAILED(hr)){
    
39.                         break;
    
40.                 }
    
41. 
    
42.                 _variant_t        vtOutObject;
    
43.                 vtOutObject.vt = VT_DISPATCH;
    
44.                 vtOutObject.pdispVal = pDispatch;
    
45.                 vtOutObject.pdispVal->AddRef();        //< required
    
46. 
    
47.                 //Apply the transformation to format the final document       
    
48.                 pXmlDoc->transformNodeToObject(fmtXml,vtOutObject);
    
49. 
    
50.                 //The default encoding method is utf-16. Change it to utf-8
    
51.                 MSXML2::IXMLDOMNodePtr pXMLFirstChild = pXMLFormattedDoc->GetfirstChild();                                // <?xml version="1.0" encoding="UTF-8"?>
    
52.                 MSXML2::IXMLDOMNamedNodeMapPtr pXMLAttributeMap =  pXMLFirstChild->Getattributes();                // A map of the a attributes (vesrsion, encoding) values (1.0, utf-8) pair
    
53.                 MSXML2::IXMLDOMNodePtr pXMLEncodNode = pXMLAttributeMap->getNamedItem(_bstr_t(L"encoding"));       
    
54.                 pXMLEncodNode->PutnodeValue(_bstr_t(L"utf-8"));//encoding = UTF-8       
    
55. 
    
56.         }while(false);
    
57.         return pXMLFormattedDoc;
    
58. }//end function: ApplyXmlIndent
    

复制代码