home *** CD-ROM | disk | FTP | other *** search
/ NEXT Generation 27 / NEXT27.iso / pc / demos / emperor / dx3.exe / SDK / SAMPLES / OCT2 / OCT2.C < prev    next >
C/C++ Source or Header  |  1996-08-28  |  14KB  |  448 lines
  1. /*==========================================================================
  2.  *
  3.  *  Copyright (C) 1995, 1996 Microsoft Corporation. All Rights Reserved.
  4.  *
  5.  *  File: oct2.c
  6.  *
  7.  ***************************************************************************/
  8.  
  9. #include <d3d.h>
  10. #include <math.h>
  11. #include "d3ddemo.h"
  12.  
  13. static D3DEXECUTEDATA d3dExData;
  14. static LPDIRECT3DEXECUTEBUFFER lpD3DExBuf;
  15. static D3DEXECUTEBUFFERDESC debDesc;
  16. LPDIRECT3DLIGHT lpD3DLight;
  17. LPDIRECT3DMATERIAL lpBmat, lpMat2;
  18.  
  19. extern LPD3DVECTOR D3DVECTORNormalise(LPD3DVECTOR);
  20.  
  21. /*
  22.  * Global projection, view, world and identity matricies
  23.  */
  24. D3DMATRIXHANDLE hProj;
  25. D3DMATRIXHANDLE hView;
  26. D3DMATRIXHANDLE hViewRot, hDViewRot;
  27. D3DMATRIXHANDLE hViewPos;
  28. D3DMATRIXHANDLE hWorld, hDWorld;
  29.  
  30. D3DMATRIX proj = {
  31.     D3DVAL(2.0), D3DVAL(0.0), D3DVAL(0.0), D3DVAL(0.0),
  32.     D3DVAL(0.0), D3DVAL(2.0), D3DVAL(0.0), D3DVAL(0.0),
  33.     D3DVAL(0.0), D3DVAL(0.0), D3DVAL(1.0), D3DVAL(1.0),
  34.     D3DVAL(0.0), D3DVAL(0.0), D3DVAL(-1.0), D3DVAL(0.0)
  35. };
  36.  
  37. D3DMATRIX viewpos = {
  38.     D3DVAL(1.0), D3DVAL(0.0), D3DVAL(0.0), D3DVAL(0.0),
  39.     D3DVAL(0.0), D3DVAL(1.0), D3DVAL(0.0), D3DVAL(0.0),
  40.     D3DVAL(0.0), D3DVAL(0.0), D3DVAL(1.0), D3DVAL(0.0),
  41.     D3DVAL(0.0), D3DVAL(0.0), D3DVAL(10.0), D3DVAL(1.0)
  42. };
  43. D3DMATRIX viewrot, view, dviewrot, dworld;
  44. D3DMATRIX identity = {
  45.     D3DVAL(1.0), D3DVAL(0.0), D3DVAL(0.0), D3DVAL(0.0),
  46.     D3DVAL(0.0), D3DVAL(1.0), D3DVAL(0.0), D3DVAL(0.0),
  47.     D3DVAL(0.0), D3DVAL(0.0), D3DVAL(1.0), D3DVAL(0.0),
  48.     D3DVAL(0.0), D3DVAL(0.0), D3DVAL(0.0), D3DVAL(1.0)
  49. };
  50.  
  51. void
  52. OverrideDefaults(Defaults* defaults)
  53. {
  54.     lstrcpy(defaults->Name, "Octagon II D3D Example");
  55. }
  56.  
  57. BOOL
  58. TickScene(LPDIRECT3DDEVICE lpDev, LPDIRECT3DVIEWPORT lpView)
  59. {
  60.     static int dir = 1;
  61.  
  62.     if (viewpos._43 < D3DVAL(4.0))
  63.         dir = 0;
  64.     if (viewpos._43 > D3DVAL(12.0))
  65.         dir = 1;
  66.     if (dir) 
  67.         viewpos._43 -= D3DVAL(0.4);
  68.     else 
  69.         viewpos._43 += D3DVAL(0.4);
  70.     if (lpDev->lpVtbl->SetMatrix(lpDev, hViewPos, &viewpos) != D3D_OK)
  71.         return FALSE;
  72.     return TRUE;
  73. }
  74.  
  75.  
  76.  
  77. BOOL
  78. RenderScene(LPDIRECT3DDEVICE lpDev, LPDIRECT3DVIEWPORT lpView,
  79.             LPD3DRECT lpExtent)
  80. {
  81.     /*
  82.      * Execute the instruction buffer
  83.      */
  84.     if (lpDev->lpVtbl->BeginScene(lpDev) != D3D_OK)
  85.         return FALSE;
  86.     if (lpDev->lpVtbl->Execute(lpDev, lpD3DExBuf, lpView, D3DEXECUTE_CLIPPED) != D3D_OK)
  87.         return FALSE;
  88.     if (lpDev->lpVtbl->EndScene(lpDev) != D3D_OK)
  89.         return FALSE;
  90.     if (lpD3DExBuf->lpVtbl->GetExecuteData(lpD3DExBuf, &d3dExData) != D3D_OK)
  91.         return FALSE;
  92.     *lpExtent = d3dExData.dsStatus.drExtent;
  93.     if (!(TickScene(lpDev, lpView)))
  94.         return FALSE;
  95.     return TRUE;
  96. }
  97.  
  98. void
  99. ReleaseScene(void)
  100. {
  101.     return;
  102. }
  103.  
  104. void
  105. ReleaseView(LPDIRECT3DVIEWPORT lpView)
  106. {
  107.     if (lpView)
  108.         lpView->lpVtbl->DeleteLight(lpView, lpD3DLight);
  109.     RELEASE(lpD3DLight);
  110.     RELEASE(lpD3DExBuf);
  111.     RELEASE(lpMat2);
  112.     RELEASE(lpBmat);
  113. }
  114.  
  115. BOOL
  116. InitScene(void)
  117. {
  118.     return TRUE;
  119. }
  120.  
  121. #define NUM_VERTICES 6
  122. #define NUM_TRIANGLES 8
  123.  
  124. BOOL
  125. InitView(LPDIRECTDRAW lpDD, LPDIRECT3D lpD3D, LPDIRECT3DDEVICE lpDev, 
  126.            LPDIRECT3DVIEWPORT lpView, int NumTextures,
  127.            LPD3DTEXTUREHANDLE TextureHandle)
  128. {
  129.     D3DVERTEX v[NUM_VERTICES];
  130.     D3DLIGHT light;
  131.     LPVOID lpBufStart, lpInsStart, lpPointer;
  132.     LPD3DTRIANGLE lpTri;
  133.     LPDIRECT3DEXECUTEBUFFER lpD3DExCmdBuf;
  134.     size_t size;
  135.     int t[8][3] = {
  136.         0, 1, 2,
  137.         0, 2, 3,
  138.         0, 3, 4,
  139.         0, 4, 1,
  140.         5, 2, 1,
  141.         5, 3, 2,
  142.         5, 4, 3,
  143.         5, 1, 4
  144.     };
  145.     D3DMATERIAL bmat, mat2;
  146.     D3DMATERIALHANDLE hBmat, hMat2;
  147.     D3DTEXTUREHANDLE bTex;
  148.     int i;
  149.     D3DVALUE ct, st;
  150.  
  151.     memset(&bmat, 0, sizeof(D3DMATERIAL));
  152.     bmat.dwSize = sizeof(D3DMATERIAL);
  153.     bmat.dwRampSize = 1;
  154.     if (lpD3D->lpVtbl->CreateMaterial(lpD3D, &lpBmat, NULL) != D3D_OK) {
  155.         return FALSE;
  156.     }
  157.     if (lpBmat->lpVtbl->SetMaterial(lpBmat, &bmat) != D3D_OK) {
  158.         return FALSE;
  159.     }
  160.     if (lpBmat->lpVtbl->GetHandle(lpBmat, lpDev, &hBmat) != D3D_OK) {
  161.         return FALSE;
  162.     }
  163.     if (lpView->lpVtbl->SetBackground(lpView, hBmat) != D3D_OK) {
  164.         return FALSE;
  165.     }
  166.  
  167.     /*
  168.      * Set the view, world and projection matrices
  169.      * Create a buffer for matrix set commands etc.
  170.      */
  171.     MAKE_MATRIX(lpDev, hViewRot, identity);
  172.     MAKE_MATRIX(lpDev, hViewPos, viewpos);
  173.     MAKE_MATRIX(lpDev, hView, identity);
  174.     MAKE_MATRIX(lpDev, hProj, proj);
  175.     MAKE_MATRIX(lpDev, hWorld, identity);
  176.     ct = D3DVAL(cos(0.1));
  177.     st = D3DVAL(sin(0.1));
  178.     dviewrot = identity;
  179.     dviewrot._22 = ct;
  180.     dviewrot._23 = -st;
  181.     dviewrot._32 = st;
  182.     dviewrot._33 = ct;
  183.     MAKE_MATRIX(lpDev, hDViewRot, dviewrot);
  184.     dworld = identity;
  185.     dworld._11 = ct;
  186.     dworld._13 = -st;
  187.     dworld._31 = st;
  188.     dworld._33 = ct;
  189.     MAKE_MATRIX(lpDev, hDWorld, dworld);
  190.     size = 0;
  191.     size += sizeof(D3DINSTRUCTION) * 3;
  192.     size += sizeof(D3DSTATE) * 4;
  193.     memset(&debDesc, 0, sizeof(D3DEXECUTEBUFFERDESC));
  194.     debDesc.dwSize = sizeof(D3DEXECUTEBUFFERDESC);
  195.     debDesc.dwFlags = D3DDEB_BUFSIZE;
  196.     debDesc.dwBufferSize = size;
  197.     if (lpDev->lpVtbl->CreateExecuteBuffer(lpDev, &debDesc, &lpD3DExCmdBuf,
  198.                                            NULL) != D3D_OK)
  199.         return FALSE;
  200.     /*
  201.      * lock it so it can be filled
  202.      */
  203.     if (lpD3DExCmdBuf->lpVtbl->Lock(lpD3DExCmdBuf, &debDesc) != D3D_OK)
  204.         return FALSE;
  205.     lpBufStart = debDesc.lpData;
  206.     memset(lpBufStart, 0, size);
  207.     lpPointer = lpBufStart;
  208.  
  209.     lpInsStart = lpPointer;
  210.     OP_STATE_TRANSFORM(3, lpPointer);
  211.         STATE_DATA(D3DTRANSFORMSTATE_PROJECTION, hProj, lpPointer);
  212.         STATE_DATA(D3DTRANSFORMSTATE_VIEW, hView, lpPointer);
  213.         STATE_DATA(D3DTRANSFORMSTATE_WORLD, hWorld, lpPointer);
  214.     OP_STATE_LIGHT(1, lpPointer);
  215.         STATE_DATA(D3DLIGHTSTATE_AMBIENT, RGBA_MAKE(64, 64, 64, 64), lpPointer);
  216.     OP_EXIT(lpPointer);
  217.     /*
  218.      * Setup the execute data describing the buffer
  219.      */
  220.     lpD3DExCmdBuf->lpVtbl->Unlock(lpD3DExCmdBuf);
  221.     memset(&d3dExData, 0, sizeof(D3DEXECUTEDATA));
  222.     d3dExData.dwSize = sizeof(D3DEXECUTEDATA);
  223.     d3dExData.dwInstructionOffset = (ULONG) 0;
  224.     d3dExData.dwInstructionLength = (ULONG) ((char *)lpPointer - (char*)lpInsStart);
  225.     lpD3DExCmdBuf->lpVtbl->SetExecuteData(lpD3DExCmdBuf, &d3dExData);
  226.     lpDev->lpVtbl->BeginScene(lpDev);
  227.     lpDev->lpVtbl->Execute(lpDev, lpD3DExCmdBuf, lpView, D3DEXECUTE_UNCLIPPED);
  228.     lpDev->lpVtbl->EndScene(lpDev);
  229.     /*
  230.      * We are done with the command buffer.
  231.      */
  232.     lpD3DExCmdBuf->lpVtbl->Release(lpD3DExCmdBuf);
  233.     /*
  234.      * Setup a material
  235.      */
  236.     bTex = TextureHandle[1];
  237.     memset(&mat2, 0, sizeof(D3DMATERIAL));
  238.     mat2.dwSize = sizeof(D3DMATERIAL);
  239.     
  240.     mat2.diffuse.r = (D3DVALUE)0.5;
  241.     mat2.diffuse.g = (D3DVALUE)0.5;
  242.     mat2.diffuse.b = (D3DVALUE)0.5;
  243.     mat2.diffuse.a = (D3DVALUE)0.5;
  244.     mat2.ambient.r = (D3DVALUE)0.8;
  245.     mat2.ambient.g = (D3DVALUE)0.8;
  246.     mat2.ambient.b = (D3DVALUE)0.8;
  247.     mat2.specular.r = (D3DVALUE)1.0;
  248.     mat2.specular.g = (D3DVALUE)1.0;
  249.     mat2.specular.b = (D3DVALUE)1.0;
  250.     mat2.power = (float)20.0;
  251.     mat2.dwRampSize = 32;
  252.     mat2.hTexture = bTex;
  253.     if (lpD3D->lpVtbl->CreateMaterial(lpD3D, &lpMat2, NULL) != D3D_OK) {
  254.         return FALSE;
  255.     }
  256.     if (lpMat2->lpVtbl->SetMaterial(lpMat2, &mat2) != D3D_OK) {
  257.         return FALSE;
  258.     }
  259.     if (lpMat2->lpVtbl->GetHandle(lpMat2, lpDev, &hMat2) != D3D_OK) {
  260.         return FALSE;
  261.     }
  262.     /*
  263.      * Setup vertices
  264.      */
  265.     memset(&v[0], 0, sizeof(D3DVERTEX) * NUM_VERTICES);
  266.     /* V 0 */
  267.     v[0].x = D3DVALP(0.0, 12);
  268.     v[0].y = D3DVALP(1.0, 12);
  269.     v[0].z = D3DVALP(1.0, 12);
  270.  
  271.     v[0].nx = D3DVALP(0.0, 12);
  272.     v[0].ny = D3DVALP(1.0, 12);
  273.     v[0].nz = D3DVALP(0.0, 12);
  274.  
  275.     v[0].tu = D3DVAL(0.0);
  276.     v[0].tv = D3DVAL(0.0);
  277.  
  278.     /* V 1 */
  279.     v[1].x = D3DVALP(1.0, 12);
  280.     v[1].y = D3DVALP(0.0, 12);
  281.     v[1].z = D3DVALP(0.0, 12);
  282.  
  283.     v[1].nx = D3DVALP(1.0, 12);
  284.     v[1].ny = D3DVALP(0.0, 12);
  285.     v[1].nz = D3DVALP(-1.0, 12);
  286.  
  287.     v[1].tu = D3DVAL(1.0);
  288.     v[1].tv = D3DVAL(1.0);
  289.  
  290.     D3DVECTORNormalise((LPD3DVECTOR) & v[1].nx);
  291.  
  292.     /* V 2 */
  293.     v[2].x = D3DVALP(-1.0, 12);
  294.     v[2].y = D3DVALP(0.0, 12);
  295.     v[2].z = D3DVALP(0.0, 12);
  296.  
  297.     v[2].nx = D3DVALP(-1.0, 12);
  298.     v[2].ny = D3DVALP(0.0, 12);
  299.     v[2].nz = D3DVALP(-1.0, 12);
  300.  
  301.     v[2].tu = D3DVAL(0.0);
  302.     v[2].tv = D3DVAL(1.0);
  303.  
  304.     D3DVECTORNormalise((LPD3DVECTOR) & v[2].nx);
  305.  
  306.     /* V 3 */
  307.     v[3].x = D3DVALP(-1.0, 12);
  308.     v[3].y = D3DVALP(0.0, 12);
  309.     v[3].z = D3DVALP(2.0, 12);
  310.  
  311.     v[3].nx = D3DVALP(-1.0, 12);
  312.     v[3].ny = D3DVALP(0.0, 12);
  313.     v[3].nz = D3DVALP(1.0, 12);
  314.  
  315.     v[3].tu = D3DVAL(1.0);
  316.     v[3].tv = D3DVAL(1.0);
  317.  
  318.     D3DVECTORNormalise((LPD3DVECTOR) & v[3].nx);
  319.  
  320.     /* V 4 */
  321.     v[4].x = D3DVALP(1.0, 12);
  322.     v[4].y = D3DVALP(0.0, 12);
  323.     v[4].z = D3DVALP(2.0, 12);
  324.  
  325.     v[4].nx = D3DVALP(1.0, 12);
  326.     v[4].ny = D3DVALP(0.0, 12);
  327.     v[4].nz = D3DVALP(1.0, 12);
  328.  
  329.     v[4].tu = D3DVAL(0.0);
  330.     v[4].tv = D3DVAL(1.0);
  331.  
  332.     D3DVECTORNormalise((LPD3DVECTOR) & v[4].nx);
  333.  
  334.     /* V 5 */
  335.     v[5].x = D3DVALP(0.0, 12);
  336.     v[5].y = D3DVALP(-1.0, 12);
  337.     v[5].z = D3DVALP(1.0, 12);
  338.  
  339.     v[5].nx = D3DVALP(0.0, 12);
  340.     v[5].ny = D3DVALP(-1.0, 12);
  341.     v[5].nz = D3DVALP(0.0, 12);
  342.  
  343.     v[5].tu = D3DVAL(0.0);
  344.     v[5].tv = D3DVAL(0.0);
  345.  
  346.     D3DVECTORNormalise((LPD3DVECTOR) & v[5].nx);
  347.  
  348.     /*
  349.      * Create an execute buffer
  350.      */
  351.     size = sizeof(D3DVERTEX) * NUM_VERTICES;
  352.     size += sizeof(D3DPROCESSVERTICES) * 2;
  353.     size += sizeof(D3DSTATUS) * 1;
  354.     size += sizeof(D3DINSTRUCTION) * 10;
  355.     size += sizeof(D3DMATRIXMULTIPLY) * 3;
  356.     size += sizeof(D3DSTATE) * 5;   
  357.     size += sizeof(D3DTRIANGLE) * NUM_TRIANGLES;
  358.     memset(&debDesc, 0, sizeof(D3DEXECUTEBUFFERDESC));
  359.     debDesc.dwSize = sizeof(D3DEXECUTEBUFFERDESC);
  360.     debDesc.dwFlags = D3DDEB_BUFSIZE;
  361.     debDesc.dwBufferSize = size;
  362.     if (lpDev->lpVtbl->CreateExecuteBuffer(lpDev, &debDesc, &lpD3DExBuf,
  363.                                            NULL) != D3D_OK) {
  364.         return FALSE;
  365.     }
  366.     if (lpD3DExBuf->lpVtbl->Lock(lpD3DExBuf, &debDesc) != D3D_OK) {
  367.         return FALSE;
  368.     }
  369.     lpBufStart = debDesc.lpData;
  370.     memset(lpBufStart, 0, size);
  371.     lpPointer = lpBufStart;
  372.     /*
  373.      * Copy vertices to execute buffer
  374.      */
  375.     VERTEX_DATA(&v[0], NUM_VERTICES, lpPointer);
  376.     /*
  377.      * Setup instructions in execute buffer
  378.      */
  379.     lpInsStart = lpPointer;
  380.     OP_MATRIX_MULTIPLY(3, lpPointer);
  381.         MATRIX_MULTIPLY_DATA(hViewRot, hDViewRot, hViewRot, lpPointer);
  382.         MATRIX_MULTIPLY_DATA(hViewRot, hViewPos, hView, lpPointer);
  383.         MATRIX_MULTIPLY_DATA(hWorld, hDWorld, hWorld, lpPointer);
  384.     OP_STATE_LIGHT(1, lpPointer);
  385.         STATE_DATA(D3DLIGHTSTATE_MATERIAL, hMat2, lpPointer);
  386.     OP_SET_STATUS(D3DSETSTATUS_ALL, D3DSTATUS_DEFAULT, 2048, 2048, 0, 0, lpPointer);
  387.     OP_PROCESS_VERTICES(1, lpPointer);
  388.         PROCESSVERTICES_DATA(D3DPROCESSVERTICES_TRANSFORMLIGHT, 0, 5, lpPointer);
  389.     OP_STATE_LIGHT(1, lpPointer);
  390.         STATE_DATA(D3DLIGHTSTATE_MATERIAL, hMat2, lpPointer);
  391.     OP_PROCESS_VERTICES(1, lpPointer);
  392.         PROCESSVERTICES_DATA(D3DPROCESSVERTICES_TRANSFORMLIGHT, 5, 1, lpPointer);
  393.     OP_STATE_RENDER(3, lpPointer);
  394.         STATE_DATA(D3DRENDERSTATE_TEXTUREHANDLE, bTex, lpPointer);
  395.         STATE_DATA(D3DRENDERSTATE_WRAPU, FALSE, lpPointer);
  396.         STATE_DATA(D3DRENDERSTATE_WRAPV, FALSE, lpPointer);
  397.     /*
  398.      * Make sure that the triangle data (not OP) will be QWORD aligned
  399.      */
  400.     if (QWORD_ALIGNED(lpPointer)) {
  401.         OP_NOP(lpPointer);
  402.     }
  403.     OP_TRIANGLE_LIST(NUM_TRIANGLES, lpPointer);
  404.         lpTri = (LPD3DTRIANGLE)lpPointer;
  405.         for (i = 0; i < NUM_TRIANGLES; i++) {
  406.             lpTri->v1 = t[i][0];
  407.             lpTri->v2 = t[i][1];
  408.             lpTri->v3 = t[i][2];
  409.             lpTri->wFlags = D3DTRIFLAG_EDGEENABLETRIANGLE;
  410.             lpTri++;
  411.         }
  412.         lpPointer = (void*)lpTri;
  413.     OP_EXIT(lpPointer);
  414.     /*
  415.      * Setup the execute data
  416.      */
  417.     lpD3DExBuf->lpVtbl->Unlock(lpD3DExBuf);
  418.     memset(&d3dExData, 0, sizeof(D3DEXECUTEDATA));
  419.     d3dExData.dwSize = sizeof(D3DEXECUTEDATA);
  420.     d3dExData.dwVertexCount = NUM_VERTICES;
  421.     d3dExData.dwInstructionOffset = (ULONG) ((char *)lpInsStart - (char *)lpBufStart);
  422.     d3dExData.dwInstructionLength = (ULONG) ((char *)lpPointer - (char*)lpInsStart);
  423.     lpD3DExBuf->lpVtbl->SetExecuteData(lpD3DExBuf, &d3dExData);
  424.     /*
  425.      * Setup lights
  426.      */
  427.     memset(&light, 0, sizeof(D3DLIGHT));
  428.     light.dwSize = sizeof(D3DLIGHT);
  429.     light.dltType = D3DLIGHT_DIRECTIONAL;
  430.     light.dcvColor.r = D3DVAL(1.0);
  431.     light.dcvColor.g = D3DVAL(1.0);
  432.     light.dcvColor.b = D3DVAL(1.0);
  433.     light.dcvColor.a = D3DVAL(1.0);
  434.     light.dvDirection.x = D3DVALP(0.0, 12);
  435.     light.dvDirection.y = D3DVALP(0.0, 12);
  436.     light.dvDirection.z = D3DVALP(1.0, 12);
  437.     if (lpD3D->lpVtbl->CreateLight(lpD3D, &lpD3DLight, NULL) != D3D_OK) {
  438.         return FALSE;
  439.     }
  440.     if (lpD3DLight->lpVtbl->SetLight(lpD3DLight, &light) != D3D_OK) {
  441.         return FALSE;
  442.     }
  443.     if (lpView->lpVtbl->AddLight(lpView, lpD3DLight) != D3D_OK) {
  444.         return FALSE;
  445.     }
  446.     return TRUE;
  447. }
  448.