vmware-svga/examples/simple-shaders/main.c

/*
 * SVGA3D example: Simple Shaders.
 *
 * This is a simple example to demonstrate the programmable pixel
 * and vertex pipelines. A vertex shader animates a rippling surface,
 * and a pixel shader generates a procedural checkerboard pattern.
 *
 * For simplicity, this example generates shader bytecode at
 * compile-time using the Microsoft HLSL compiler.
 *
 * 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"

typedef uint32 DWORD;
#include "simple_vs.h"
#include "simple_ps.h"

/*
 * Small integers to identify our shaders.
 */
#define MY_VSHADER_ID       0
#define MY_PSHADER_ID       0

/*
 * Shader constants. These must match the constant registers in the
 * bytecode we send the device, so in this example the constants are
 * actually assigned by the Microsoft HLSL compiler.
 */
#define CONST_MAT_WORLDVIEWPROJ   0
#define CONST_TIMESTEP            4

/*
 * Macros for the simple mesh we generate as input for the vertex
 * shader.  It's a static grid in the XY plane.
 */
#define MESH_WIDTH      256
#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_ELEMENT(x, y)  (MESH_WIDTH * (y) + (x))

typedef struct {
   float position[3];
} MyVertex;

typedef uint16 IndexType;
uint32 vertexSid, indexSid;
FPSCounterState gFPS;


/*
 * render --
 *
 *    Set up render state that we load once per frame (because
 *    SVGA3DText clobbered it) and render the scene.
 */

void
render(void)
{
   SVGA3dVertexDecl *decls;
   SVGA3dPrimitiveRange *ranges;
   SVGA3dRenderState *rs;

   float shaderTimestep[4] = { gFPS.frame * 0.01 };

   SVGA3D_SetShaderConst(CID, CONST_TIMESTEP, SVGA3D_SHADERTYPE_VS,
                         SVGA3D_CONST_TYPE_FLOAT, shaderTimestep);

   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_SetShader(CID, SVGA3D_SHADERTYPE_VS, MY_VSHADER_ID);
   SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_PS, MY_PSHADER_ID);

   SVGA3D_BeginDrawPrimitives(CID, &decls, 1, &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);

      ranges[0].primType = SVGA3D_PRIMITIVE_TRIANGLELIST;
      ranges[0].primitiveCount = MESH_NUM_TRIANGLES;
      ranges[0].indexArray.surfaceId = indexSid;
      ranges[0].indexArray.stride = sizeof(IndexType);
      ranges[0].indexWidth = sizeof(IndexType);
   }
   SVGA_FIFOCommitAll();

   SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_VS, SVGA3D_INVALID_ID);
   SVGA3D_SetShader(CID, SVGA3D_SHADERTYPE_PS, SVGA3D_INVALID_ID);
}


/*
 * 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;
}


/*
 * createVertexBuffer --
 *
 *    Create a static vertex buffer that renders a mesh on thee XY
 *    plane. For simplicity, we use a triangle list rather than a
 *    triangle strip.
 */

uint32
createVertexBuffer(void)
{
   MyVertex *vert;
   const uint32 bufferSize = MESH_NUM_VERTICES * sizeof(MyVertex);
   SVGAGuestPtr gPtr;
   uint32 sid;
   int x, y;

   sid = SVGA3DUtil_DefineSurface2D(bufferSize, 1, SVGA3D_BUFFER);
   vert = SVGA3DUtil_AllocDMABuffer(bufferSize, &gPtr);

   for (y = 0; y < MESH_HEIGHT; y++) {
      for (x = 0; x < MESH_WIDTH; x++) {

         vert->position[0] = x * (2.0 / MESH_WIDTH) - 1.0;
         vert->position[1] = y * (2.0 / MESH_HEIGHT) - 1.0;
         vert->position[2] = 0.0f;

         vert++;
      }
   }

   SVGA3DUtil_SurfaceDMA2D(sid, &gPtr, SVGA3D_WRITE_HOST_VRAM, bufferSize, 1);

   return sid;
}


/*
 * main --
 *
 *    Our example's entry point, invoked directly by the bootloader.
 */

int
main(void)
{
   Matrix worldViewProj, proj;

   SVGA3DUtil_InitFullscreen(CID, 800, 600);
   SVGA3DText_Init();

   vertexSid = createVertexBuffer();
   indexSid = createIndexBuffer();

   SVGA3D_DefineShader(CID, MY_VSHADER_ID, SVGA3D_SHADERTYPE_VS,
                       g_vs20_MyVertexShader, sizeof g_vs20_MyVertexShader);
   SVGA3D_DefineShader(CID, MY_PSHADER_ID, SVGA3D_SHADERTYPE_PS,
                       g_ps20_MyPixelShader, sizeof g_ps20_MyPixelShader);

   /*
    * Compute a single matrix for the world, view, and projection
    * transforms, then upload that to the shader.
    */

   Matrix_Copy(worldViewProj, gIdentityMatrix);
   Matrix_RotateX(worldViewProj, 60.0 * PI_OVER_180);
   Matrix_Translate(worldViewProj, 0, 0, 3);
   Matrix_Perspective(proj, 45.0f, gSVGA.width / (float)gSVGA.height, 0.1f, 100.0f);
   Matrix_Multiply(worldViewProj, proj);

   SVGA3DUtil_SetShaderConstMatrix(CID, CONST_MAT_WORLDVIEWPROJ,
                                   SVGA3D_SHADERTYPE_VS, worldViewProj);

   while (1) {
      if (SVGA3DUtil_UpdateFPSCounter(&gFPS)) {
         Console_Clear();
         Console_Format("VMware SVGA3D Example:\n"
                        "Simple Shaders.\n\n%s",
                        gFPS.text);
         SVGA3DText_Update();
      }

      SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR | SVGA3D_CLEAR_DEPTH,
                                 0x113366, 1.0f, 0);
      render();
      SVGA3DText_Draw();
      SVGA3DUtil_PresentFullscreen();
   }

   return 0;
}