home *** CD-ROM | disk | FTP | other *** search
/ NEXT Generation 27 / NEXT27.iso / pc / demos / emperor / dx3.exe / SDK / SAMPLES / TRIANGLE / TRIANGLE.C < prev    next >
C/C++ Source or Header  |  1996-08-28  |  7KB  |  223 lines
  1. /*==========================================================================
  2.  *
  3.  *  Copyright (C) 1995, 1996 Microsoft Corporation. All Rights Reserved.
  4.  *
  5.  *  File: triangle.c
  6.  *
  7.  ***************************************************************************/
  8.  
  9. #include <math.h>
  10. #include <d3d.h>
  11. #include "d3ddemo.h"
  12.  
  13. static D3DEXECUTEDATA d3dExData;
  14. static LPDIRECT3DEXECUTEBUFFER lpD3DExBuf;
  15. LPDIRECT3DMATERIAL lpBmat, lpMat1;
  16. #define NUM_VERTICES 3
  17. #define NUM_TRIANGLES 1
  18.  
  19. void
  20. OverrideDefaults(Defaults* defaults)
  21. {
  22.     lstrcpy(defaults->Name, "Triangle D3D Example");
  23.     defaults->rs.bPerspCorrect = FALSE;
  24.     defaults->bResizingDisabled = TRUE;
  25. }
  26.  
  27. BOOL
  28. RenderScene(LPDIRECT3DDEVICE lpDev, LPDIRECT3DVIEWPORT lpView,
  29.             LPD3DRECT lpExtent)
  30. {
  31.     /*
  32.      * Execute the instruction buffer
  33.      */
  34.     if (lpDev->lpVtbl->BeginScene(lpDev) != D3D_OK)
  35.         return FALSE;
  36.     if (lpDev->lpVtbl->Execute(lpDev, lpD3DExBuf,
  37.                                lpView, D3DEXECUTE_UNCLIPPED) != D3D_OK)
  38.         return FALSE;
  39.     if (lpDev->lpVtbl->EndScene(lpDev) != D3D_OK)
  40.         return FALSE;
  41.     if (lpD3DExBuf->lpVtbl->GetExecuteData(lpD3DExBuf, &d3dExData) != D3D_OK)
  42.         return FALSE;
  43.     *lpExtent = d3dExData.dsStatus.drExtent;
  44.     return TRUE;
  45. }
  46.  
  47. void
  48. ReleaseScene(void)
  49. {
  50.     return;
  51. }
  52.  
  53. void
  54. ReleaseView(LPDIRECT3DVIEWPORT lpView)
  55. {
  56.     lpView;
  57.     RELEASE(lpD3DExBuf);
  58.     RELEASE(lpMat1);
  59.     RELEASE(lpBmat);
  60. }
  61.  
  62. BOOL
  63. InitScene(void)
  64. {
  65.     return TRUE;
  66. }
  67.  
  68. BOOL
  69. InitView(LPDIRECTDRAW lpDD, LPDIRECT3D lpD3D, LPDIRECT3DDEVICE lpDev,
  70.            LPDIRECT3DVIEWPORT lpView, int NumTextures,
  71.            LPD3DTEXTUREHANDLE TextureHandle)
  72. {
  73.     LPVOID lpBufStart, lpInsStart, lpPointer;
  74.     D3DEXECUTEBUFFERDESC debDesc;
  75.     size_t size;
  76.     D3DTLVERTEX src_v[NUM_VERTICES];
  77.     int t[8][3] = {
  78.         0, 1, 2,
  79.     };
  80.     D3DMATERIAL bmat, mat;
  81.     D3DMATERIALHANDLE hBmat, hMat1;
  82.  
  83.     if (lpD3D->lpVtbl->CreateMaterial(lpD3D, &lpBmat, NULL) != D3D_OK) {
  84.         return FALSE;
  85.     }
  86.     memset(&bmat, 0, sizeof(D3DMATERIAL));
  87.     bmat.dwSize = sizeof(D3DMATERIAL);
  88.     bmat.diffuse.r = (D3DVALUE)1.0;
  89.     bmat.diffuse.g = (D3DVALUE)1.0;
  90.     bmat.diffuse.b = (D3DVALUE)1.0;
  91.     bmat.ambient.r = (D3DVALUE)1.0;
  92.     bmat.ambient.g = (D3DVALUE)1.0;
  93.     bmat.ambient.b = (D3DVALUE)1.0;
  94.     bmat.hTexture = TextureHandle[0];
  95.     bmat.dwRampSize = 1;
  96.     lpBmat->lpVtbl->SetMaterial(lpBmat, &bmat);
  97.     lpBmat->lpVtbl->GetHandle(lpBmat, lpDev, &hBmat);
  98.     lpView->lpVtbl->SetBackground(lpView, hBmat);
  99.  
  100.     if (lpD3D->lpVtbl->CreateMaterial(lpD3D, &lpMat1, NULL) != D3D_OK) {
  101.         return FALSE;
  102.     }
  103.     memset(&mat, 0, sizeof(D3DMATERIAL));
  104.     mat.dwSize = sizeof(D3DMATERIAL);
  105.     mat.diffuse.r = (D3DVALUE)1.0;
  106.     mat.diffuse.g = (D3DVALUE)1.0;
  107.     mat.diffuse.b = (D3DVALUE)1.0;
  108.     mat.ambient.r = (D3DVALUE)1.0;
  109.     mat.ambient.g = (D3DVALUE)1.0;
  110.     mat.ambient.b = (D3DVALUE)1.0;
  111. #define SPECULAR
  112. #ifdef SPECULAR
  113.     mat.specular.r = (D3DVALUE)1.0;
  114.     mat.specular.g = (D3DVALUE)1.0;
  115.     mat.specular.b = (D3DVALUE)1.0;
  116.     mat.power = (float)40.0;
  117. #else
  118.     mat.specular.r = (D3DVALUE)0.0;
  119.     mat.specular.g = (D3DVALUE)0.0;
  120.     mat.specular.b = (D3DVALUE)0.0;
  121.     mat.power = (float)0.0;
  122. #endif    
  123.     mat.hTexture = TextureHandle[1];
  124.     mat.dwRampSize = 16;
  125.     lpMat1->lpVtbl->SetMaterial(lpMat1, &mat);
  126.     lpMat1->lpVtbl->GetHandle(lpMat1, lpDev, &hMat1);
  127.     /*
  128.      * Setup vertices
  129.      */
  130.     memset(&src_v[0], 0, sizeof(D3DVERTEX) * NUM_VERTICES);
  131.     /* V 0 */
  132.     src_v[0].sx = D3DVAL(10.0);
  133.     src_v[0].sy = D3DVAL(10.0);
  134.     src_v[0].sz = D3DVAL(0.1);
  135.     src_v[0].rhw = D3DVAL(1.0);
  136.     src_v[0].color = RGBA_MAKE(255, 0, 255, 255);
  137.     src_v[0].specular = RGB_MAKE(0, 0, 255);
  138.     src_v[0].tu = D3DVAL(0.0);
  139.     src_v[0].tv = D3DVAL(0.0);
  140.     /* V 1 */
  141.     src_v[1].sx = D3DVAL(300.0);
  142.     src_v[1].sy = D3DVAL(50.0);
  143.     src_v[1].sz = D3DVAL(0.9);
  144.     src_v[1].rhw = D3DVAL(2.0);
  145.     src_v[1].color = RGBA_MAKE(255, 255, 255, 255);
  146.     src_v[1].specular = RGB_MAKE(0, 0, 0);
  147.     src_v[1].tu = D3DVAL(1.0);
  148.     src_v[1].tv = D3DVAL(1.0);
  149.     /* V 2 */
  150.     src_v[2].sx = D3DVAL(150.0);
  151.     src_v[2].sy = D3DVAL(180.0);
  152.     src_v[2].sz = D3DVAL(0.6);
  153.     src_v[2].rhw = D3DVAL(1.0);
  154.     src_v[2].color = RGBA_MAKE(255, 255, 0, 255);
  155.     src_v[2].specular = RGB_MAKE(0, 0, 0);
  156.     src_v[2].tu = D3DVAL(0.0);
  157.     src_v[2].tv = D3DVAL(1.0);
  158.     /*
  159.      * Create an execute buffer
  160.      */
  161.     size = sizeof(D3DVERTEX) * NUM_VERTICES;
  162.     size += sizeof(D3DINSTRUCTION) * 6;
  163.     size += sizeof(D3DSTATE) * 2;
  164.     size += sizeof(D3DPROCESSVERTICES);
  165.     size += sizeof(D3DTRIANGLE) * 1;
  166.     memset(&debDesc, 0, sizeof(D3DEXECUTEBUFFERDESC));
  167.     debDesc.dwSize = sizeof(D3DEXECUTEBUFFERDESC);
  168.     debDesc.dwFlags = D3DDEB_BUFSIZE;
  169.     debDesc.dwBufferSize = size;
  170.     if (lpDev->lpVtbl->CreateExecuteBuffer(lpDev, &debDesc, &lpD3DExBuf,
  171.                                            NULL) != D3D_OK) {
  172.         return FALSE;
  173.     }
  174.     if (lpD3DExBuf->lpVtbl->Lock(lpD3DExBuf, &debDesc) != D3D_OK) {
  175.         return FALSE;
  176.     }
  177.     lpBufStart = debDesc.lpData;
  178.     memset(lpBufStart, 0, size);
  179.     lpPointer = lpBufStart;
  180.  
  181.     /*
  182.      * Copy vertices to execute buffer
  183.      */
  184.     VERTEX_DATA(&src_v[0], NUM_VERTICES, lpPointer);
  185.     /*
  186.      * Setup instructions in execute buffer
  187.      */
  188.     lpInsStart = lpPointer;
  189.     OP_STATE_LIGHT(1, lpPointer);
  190.         STATE_DATA(D3DLIGHTSTATE_MATERIAL, hMat1, lpPointer);
  191.     OP_PROCESS_VERTICES(1, lpPointer);
  192.         PROCESSVERTICES_DATA(D3DPROCESSVERTICES_COPY |
  193.                              D3DPROCESSVERTICES_UPDATEEXTENTS, 0, NUM_VERTICES, lpPointer);
  194.     OP_STATE_RENDER(1, lpPointer);
  195.         STATE_DATA(D3DRENDERSTATE_TEXTUREHANDLE, TextureHandle[1], lpPointer);
  196.     /*
  197.      * Make sure that the triangle data (not OP) will be QWORD aligned
  198.      */
  199.     if (QWORD_ALIGNED(lpPointer)) {
  200.         OP_NOP(lpPointer);
  201.     }
  202.     OP_TRIANGLE_LIST(1, lpPointer);
  203.         ((LPD3DTRIANGLE)lpPointer)->v1 = 0;
  204.         ((LPD3DTRIANGLE)lpPointer)->v2 = 1;
  205.         ((LPD3DTRIANGLE)lpPointer)->v3 = 2;
  206.         ((LPD3DTRIANGLE)lpPointer)->wFlags = D3DTRIFLAG_EDGEENABLETRIANGLE;
  207.         lpPointer = ((char*)lpPointer) + sizeof(D3DTRIANGLE);
  208.     OP_EXIT(lpPointer);
  209.     /*
  210.      * Setup the execute data
  211.      */
  212.     lpD3DExBuf->lpVtbl->Unlock(lpD3DExBuf);
  213.     memset(&d3dExData, 0, sizeof(D3DEXECUTEDATA));
  214.     d3dExData.dwSize = sizeof(D3DEXECUTEDATA);
  215.     d3dExData.dwVertexCount = NUM_VERTICES;
  216.     d3dExData.dwInstructionOffset = (ULONG) ((char *)lpInsStart - (char *)lpBufStart);
  217.     d3dExData.dwInstructionLength = (ULONG) ((char *)lpPointer - (char *)lpInsStart);
  218.     lpD3DExBuf->lpVtbl->SetExecuteData(lpD3DExBuf, &d3dExData);
  219.  
  220.     return TRUE;
  221. }
  222.  
  223.