/* * SVGA3D example: Dynamic vertex buffer stress-test. * * This example is a performance stress-test for dynamic vertex * buffers, and specifically for performing DMA on buffers which may * still be in use by the GPU. * * Like the original dynamic-vertex test, we compute an animated * function on the guest CPU and upload it via a vertex buffer before * each draw. To simulate the stresses involved in dealing with apps * that render in immediate-mode, however, this test breaks the vertex * buffer up into very small pieces which are all DMA'ed and rendered * individually. * * If the SVGA3D implementation has any bottlenecks related to reusing * vertex buffers that are still in use by the physical GPU, this test * will expose them. * * Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT * License, please see the README.txt. All rights reserved. */ #include "svga3dutil.h" #include "svga3dtext.h" #include "matrix.h" #include "math.h" #define MESH_WIDTH 256 /* 64 kilovertices, 1.5MB */ #define MESH_HEIGHT 256 #define MESH_NUM_VERTICES (MESH_WIDTH * MESH_HEIGHT) #define MESH_NUM_QUADS ((MESH_WIDTH-1) * (MESH_HEIGHT-1)) #define MESH_NUM_TRIANGLES (MESH_NUM_QUADS * 2) #define MESH_NUM_INDICES (MESH_NUM_TRIANGLES * 3) #define MESH_NUM_BYTES (MESH_NUM_VERTICES * sizeof(MyVertex)) #define TRIANGLES_PER_ROW ((MESH_WIDTH-1) * 2) #define INDICES_PER_ROW (TRIANGLES_PER_ROW * 3) #define MESH_ELEMENT(x, y) (MESH_WIDTH * (y) + (x)) typedef struct { float position[3]; float color[3]; } MyVertex; typedef uint16 IndexType; DMAPool vertexDMA; uint32 vertexSid, indexSid; Matrix perspectiveMat; FPSCounterState gFPS; /* * setupFrame -- * * Set up render state that we load once per frame (because * SVGA3DText clobbered it) and perform matrix calculations that we * only need once per frame. */ void setupFrame(void) { static Matrix world; static Matrix view; SVGA3dTextureState *ts; SVGA3dRenderState *rs; Matrix_Copy(view, gIdentityMatrix); Matrix_Translate(view, 0, 0, 3); SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_VIEW, view); Matrix_Copy(world, gIdentityMatrix); Matrix_RotateX(world, -60.0 * PI_OVER_180); Matrix_RotateY(world, gFPS.frame * 0.01f); SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_WORLD, world); SVGA3D_SetTransform(CID, SVGA3D_TRANSFORM_PROJECTION, perspectiveMat); SVGA3D_BeginSetRenderState(CID, &rs, 4); { rs[0].state = SVGA3D_RS_BLENDENABLE; rs[0].uintValue = FALSE; rs[1].state = SVGA3D_RS_ZENABLE; rs[1].uintValue = TRUE; rs[2].state = SVGA3D_RS_ZWRITEENABLE; rs[2].uintValue = TRUE; rs[3].state = SVGA3D_RS_ZFUNC; rs[3].uintValue = SVGA3D_CMP_LESS; } SVGA_FIFOCommitAll(); SVGA3D_BeginSetTextureState(CID, &ts, 4); { ts[0].stage = 0; ts[0].name = SVGA3D_TS_BIND_TEXTURE; ts[0].value = SVGA3D_INVALID_ID; ts[1].stage = 0; ts[1].name = SVGA3D_TS_COLOROP; ts[1].value = SVGA3D_TC_SELECTARG1; ts[2].stage = 0; ts[2].name = SVGA3D_TS_COLORARG1; ts[2].value = SVGA3D_TA_DIFFUSE; ts[3].stage = 0; ts[3].name = SVGA3D_TS_ALPHAARG1; ts[3].value = SVGA3D_TA_DIFFUSE; } SVGA_FIFOCommitAll(); } /* * updateVertices -- * * Calculate new vertices, writing them directly into an available * DMA buffer. Returns a DMAPoolBuffer which contains the vertex * data for an entire frame. */ DMAPoolBuffer * updateVertices(float red, float green, float blue, float phase, float offset) { DMAPoolBuffer *dma; MyVertex *vert; int x, y; float t = gFPS.frame * 0.1f + phase; dma = SVGA3DUtil_DMAPoolGetBuffer(&vertexDMA); vert = (MyVertex*) dma->buffer; for (y = 0; y < MESH_HEIGHT; y++) { for (x = 0; x < MESH_WIDTH; x++) { float fx = x * (2.0 / MESH_WIDTH) - 1.0; float fy = y * (2.0 / MESH_HEIGHT) - 1.0; float fxo = fx + offset; float dist = fxo * fxo + fy * fy; float z = sinf(dist * 8.0 + t) / (1 + dist * 10.0); vert->position[0] = fx; vert->position[1] = fy; vert->position[2] = z; vert->color[0] = red - z; vert->color[1] = green - z; vert->color[2] = blue - z; vert++; } } return dma; } /* * createIndexBuffer -- * * Create a static index buffer that renders our vertices as a 2D * mesh. For simplicity, we use a triangle list rather than a * triangle strip. */ uint32 createIndexBuffer(void) { IndexType *indexBuffer; const uint32 bufferSize = MESH_NUM_INDICES * sizeof *indexBuffer; SVGAGuestPtr gPtr; uint32 sid; int x, y; sid = SVGA3DUtil_DefineSurface2D(bufferSize, 1, SVGA3D_BUFFER); indexBuffer = SVGA3DUtil_AllocDMABuffer(bufferSize, &gPtr); for (y = 0; y < (MESH_HEIGHT - 1); y++) { for (x = 0; x < (MESH_WIDTH - 1); x++) { indexBuffer[0] = MESH_ELEMENT(x, y ); indexBuffer[1] = MESH_ELEMENT(x+1, y ); indexBuffer[2] = MESH_ELEMENT(x+1, y+1); indexBuffer[3] = MESH_ELEMENT(x+1, y+1); indexBuffer[4] = MESH_ELEMENT(x, y+1); indexBuffer[5] = MESH_ELEMENT(x, y ); indexBuffer += 6; } } SVGA3DUtil_SurfaceDMA2D(sid, &gPtr, SVGA3D_WRITE_HOST_VRAM, bufferSize, 1); return sid; } /* * trashBuffer -- * * Upload zeroes to the vertex buffer, to make any future DMA errors obvious. */ void trashBuffer(void) { DMAPoolBuffer *dma = SVGA3DUtil_DMAPoolGetBuffer(&vertexDMA); memset(dma->buffer, 0, MESH_NUM_BYTES); SVGA3DUtil_SurfaceDMA2D(vertexSid, &dma->ptr, SVGA3D_WRITE_HOST_VRAM, MESH_NUM_BYTES, 1); SVGA3DUtil_AsyncCall((AsyncCallFn) SVGA3DUtil_DMAPoolFreeBuffer, dma); } /* * uploadRow -- * * Upload the vertex data for one row of the mesh. */ void uploadRow(int row, DMAPoolBuffer *dma) { SVGA3dCopyBox *boxes; SVGA3dGuestImage guestImage; SVGA3dSurfaceImageId hostImage = { vertexSid }; guestImage.ptr = dma->ptr; guestImage.pitch = 0; SVGA3D_BeginSurfaceDMA(&guestImage, &hostImage, SVGA3D_WRITE_HOST_VRAM, &boxes, 1); { boxes[0].x = MESH_HEIGHT * sizeof(MyVertex) * row; boxes[0].w = MESH_WIDTH * sizeof(MyVertex); boxes[0].srcx = boxes[0].x; boxes[0].h = 1; boxes[0].d = 1; } SVGA_FIFOCommitAll(); } /* * drawStrip -- * * Draw all triangles between 'row' and 'row+1'. */ void drawStrip(int row) { SVGA3dVertexDecl *decls; SVGA3dPrimitiveRange *ranges; SVGA3D_BeginDrawPrimitives(CID, &decls, 2, &ranges, 1); { decls[0].identity.type = SVGA3D_DECLTYPE_FLOAT3; decls[0].identity.usage = SVGA3D_DECLUSAGE_POSITION; decls[0].array.surfaceId = vertexSid; decls[0].array.stride = sizeof(MyVertex); decls[0].array.offset = offsetof(MyVertex, position); decls[1].identity.type = SVGA3D_DECLTYPE_FLOAT3; decls[1].identity.usage = SVGA3D_DECLUSAGE_COLOR; decls[1].array.surfaceId = vertexSid; decls[1].array.stride = sizeof(MyVertex); decls[1].array.offset = offsetof(MyVertex, color); ranges[0].primType = SVGA3D_PRIMITIVE_TRIANGLELIST; ranges[0].primitiveCount = TRIANGLES_PER_ROW; ranges[0].indexArray.surfaceId = indexSid; ranges[0].indexArray.stride = sizeof(IndexType); ranges[0].indexArray.offset = sizeof(IndexType) * INDICES_PER_ROW * row; ranges[0].indexWidth = sizeof(IndexType); } SVGA_FIFOCommitAll(); } /* * render -- * * Calculate, upload, and draw the entire mesh. */ void render(void) { DMAPoolBuffer *dma = updateVertices(0.2, 0.8, 0.2, 0, 0); int row; trashBuffer(); uploadRow(0, dma); for (row = 1; row < MESH_HEIGHT; row++) { uploadRow(row, dma); drawStrip(row - 1); } SVGA3DUtil_AsyncCall((AsyncCallFn) SVGA3DUtil_DMAPoolFreeBuffer, dma); } /* * main -- * * Our example's entry point, invoked directly by the bootloader. */ int main(void) { SVGA3DUtil_InitFullscreen(CID, 800, 600); SVGA3DText_Init(); vertexSid = SVGA3DUtil_DefineSurface2D(MESH_NUM_BYTES, 1, SVGA3D_BUFFER); indexSid = createIndexBuffer(); SVGA3DUtil_AllocDMAPool(&vertexDMA, MESH_NUM_BYTES, 16); Matrix_Perspective(perspectiveMat, 45.0f, gSVGA.width / (float)gSVGA.height, 0.1f, 100.0f); while (1) { if (SVGA3DUtil_UpdateFPSCounter(&gFPS)) { Console_Clear(); Console_Format("VMware SVGA3D Example:\n" "Dynamic vertex buffer stress-test.\n" "This example performs a separate DMA and " "Draw for each row of the mesh.\n\n%s", gFPS.text); SVGA3DText_Update(); } SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR | SVGA3D_CLEAR_DEPTH, 0x113366, 1.0f, 0); setupFrame(); render(); SVGA3DText_Draw(); SVGA3DUtil_PresentFullscreen(); } return 0; }