tunnel.cpp

国外游戏开发者杂志1997年第九期配套代码

     * Set background to black material
     */
    if (lpD3D->CreateMaterial(&lpbmat, NULL) != D3D_OK)
        return FALSE;
    memset(&bmat, 0, sizeof(D3DMATERIAL));
    bmat.dwSize = sizeof(D3DMATERIAL);
    bmat.dwRampSize = 1;
    lpbmat->SetMaterial(&bmat);
    lpbmat->GetHandle(lpDev, &hbmat);
    lpView->SetBackground(hbmat);
    /*
     * Set the view, projection and world matrices in an execute buffer
     */
    MAKE_MATRIX(lpDev, hView, view);
    MAKE_MATRIX(lpDev, hProj, ProjectionMatrix());
    MAKE_MATRIX(lpDev, hWorld, IdentityMatrix());
    /*
     * Create an execute buffer
     */
    size = 0;
    size += sizeof(D3DINSTRUCTION) * 3;
    size += sizeof(D3DSTATE) * 4;
    memset(&debDesc, 0, sizeof(D3DEXECUTEBUFFERDESC));
    debDesc.dwSize = sizeof(D3DEXECUTEBUFFERDESC);
    debDesc.dwFlags = D3DDEB_BUFSIZE;
    debDesc.dwBufferSize = size;
    if (lpDev->CreateExecuteBuffer(&debDesc, &lpD3DExCmdBuf, NULL) != D3D_OK)
        return FALSE;
    if (lpD3DExCmdBuf->Lock(&debDesc) != D3D_OK)
        return FALSE;
    lpBufStart = debDesc.lpData;
    memset(lpBufStart, 0, size);
    lpPointer = lpBufStart;
    /*
     * Fill the execute buffer with instructions
     */
    lpInsStart = lpPointer;
    OP_STATE_TRANSFORM(3, lpPointer);
        STATE_DATA(D3DTRANSFORMSTATE_WORLD, hWorld, lpPointer);
        STATE_DATA(D3DTRANSFORMSTATE_VIEW, hView, lpPointer);
        STATE_DATA(D3DTRANSFORMSTATE_PROJECTION, hProj, lpPointer);
    OP_STATE_LIGHT(1, lpPointer);
        STATE_DATA(D3DLIGHTSTATE_AMBIENT, RGBA_MAKE(40, 40, 40, 40), lpPointer);
    OP_EXIT(lpPointer);
    /*
     * Setup the execute data describing the buffer
     */
    lpD3DExCmdBuf->Unlock();
    memset(&d3dExData, 0, sizeof(D3DEXECUTEDATA));
    d3dExData.dwSize = sizeof(D3DEXECUTEDATA);
    d3dExData.dwInstructionOffset = (ULONG) 0;
    d3dExData.dwInstructionLength = (ULONG) ((char *)lpPointer - (char*)lpInsStart);
    lpD3DExCmdBuf->SetExecuteData(&d3dExData);
    lpDev->BeginScene();
    lpDev->Execute(lpD3DExCmdBuf, lpView, D3DEXECUTE_UNCLIPPED);
    lpDev->EndScene();
    /*
     * We are done with the command buffer.
     */
    lpD3DExCmdBuf->Release();
    /*
     * Setup materials and lights
     */
    tube.hTex = TextureHandle[1];
    if (lpD3D->CreateMaterial(&lpmat, NULL) != D3D_OK)
        return FALSE;
    memset(&mat, 0, sizeof(D3DMATERIAL));
    mat.dwSize = sizeof(D3DMATERIAL);
    mat.diffuse.r = (D3DVALUE)1.0;
    mat.diffuse.g = (D3DVALUE)1.0;
    mat.diffuse.b = (D3DVALUE)1.0;
    mat.diffuse.a = (D3DVALUE)1.0;
    mat.ambient.r = (D3DVALUE)1.0;
    mat.ambient.g = (D3DVALUE)1.0;
    mat.ambient.b = (D3DVALUE)1.0;
    mat.specular.r = (D3DVALUE)1.0;
    mat.specular.g = (D3DVALUE)1.0;
    mat.specular.b = (D3DVALUE)1.0;
    mat.power = (float)20.0;
    mat.dwRampSize = 16;
    mat.hTexture = tube.hTex;
    lpmat->SetMaterial(&mat);
    lpmat->GetHandle(lpDev, &tube.hMat);

    memset(&tube.light, 0, sizeof(D3DLIGHT));
    tube.light.dwSize = sizeof(D3DLIGHT);
    tube.light.dltType = D3DLIGHT_POINT;
    tube.light.dvPosition = tube.cameraP;
    tube.light.dcvColor.r = D3DVAL(0.9);
    tube.light.dcvColor.g = D3DVAL(0.9);
    tube.light.dcvColor.b = D3DVAL(0.9);
    tube.light.dvAttenuation0 = (float)0.0;
    tube.light.dvAttenuation1 = (float)0.0;
    tube.light.dvAttenuation2 = (float)0.05;
    if (lpD3D->CreateLight(&tube.lpD3DLight, NULL)!=D3D_OK)
        return FALSE;
    if (tube.lpD3DLight->SetLight(&tube.light)
        !=D3D_OK)
        return FALSE;
    if (lpView->AddLight(tube.lpD3DLight) != D3D_OK)
        return FALSE;

    /*
     * Create an execute buffer
     */
    size = sizeof(D3DVERTEX) * NUM_V;
    size += sizeof(D3DPROCESSVERTICES);
    size += sizeof(D3DINSTRUCTION) * 6;
    size += sizeof(D3DSTATE) * 4;
    size += sizeof(D3DTRIANGLE) * NUM_TRI;
    memset(&debDesc, 0, sizeof(D3DEXECUTEBUFFERDESC));
    debDesc.dwSize = sizeof(D3DEXECUTEBUFFERDESC);
    debDesc.dwFlags = D3DDEB_BUFSIZE;
    debDesc.dwBufferSize = size;
    if (lpDev->CreateExecuteBuffer(&debDesc, &lpD3DExBuf, NULL) != D3D_OK)
        return FALSE;
    /*
     * lock it so it can be filled
     */
    if (lpD3DExBuf->Lock(&debDesc) != D3D_OK)
        return FALSE;
    lpBufStart = debDesc.lpData;
    memset(lpBufStart, 0, size);
    lpPointer = lpBufStart;
    VERTEX_DATA(tube.lpV, NUM_V, lpPointer);
    /*
     * Save the location of the first instruction and add instructions to
     * execute buffer.
     */
    lpInsStart = lpPointer;
    OP_STATE_LIGHT(1, lpPointer);
        STATE_DATA(D3DLIGHTSTATE_MATERIAL, tube.hMat, lpPointer);
    OP_PROCESS_VERTICES(1, lpPointer);
        PROCESSVERTICES_DATA(D3DPROCESSVERTICES_TRANSFORMLIGHT, 0, NUM_V, lpPointer);
    OP_STATE_RENDER(3, lpPointer);
        STATE_DATA(D3DRENDERSTATE_TEXTUREHANDLE, tube.hTex, lpPointer);
        STATE_DATA(D3DRENDERSTATE_WRAPU, TRUE, lpPointer);
        STATE_DATA(D3DRENDERSTATE_WRAPV, TRUE, lpPointer);
    /*
     * Make sure that the triangle data (not OP) will be QWORD aligned
     */
    if (QWORD_ALIGNED(lpPointer)) {
        OP_NOP(lpPointer);
    }
    OP_TRIANGLE_LIST(NUM_TRI, lpPointer);
        tube.TriOffset = (char *)lpPointer - (char *)lpBufStart;
        TRIANGLE_LIST_DATA(tube.lpTri, NUM_TRI, lpPointer);
    OP_EXIT(lpPointer);
    /*
     * Setup the execute data describing the buffer
     */
    lpD3DExBuf->Unlock();
    memset(&d3dExData, 0, sizeof(D3DEXECUTEDATA));
    d3dExData.dwSize = sizeof(D3DEXECUTEDATA);
    d3dExData.dwVertexCount = NUM_V;
    d3dExData.dwInstructionOffset = (ULONG) ((char *)lpInsStart - (char *)lpBufStart);
    d3dExData.dwInstructionLength = (ULONG) ((char *)lpPointer - (char *)lpInsStart);
    lpD3DExBuf->SetExecuteData(&d3dExData);

    
#if  defined(SW_SPOT)
  if(! InitViewSW( lpDD, lpD3D, lpDev, lpView, NumTextures, TextureHandle))
		 return FALSE;
#endif	
return TRUE;
}

/******************************************************************************************************/
/* Here we initial the execute buffer for the software object															*/
/******************************************************************************************************/
BOOL
InitViewSW(LPDIRECTDRAW lpDD, LPDIRECT3D lpD3D, LPDIRECT3DDEVICE lpDev,
	   LPDIRECT3DVIEWPORT lpView, int NumTextures,
	   LPD3DTEXTUREHANDLE TextureHandle)
{
    LPVOID lpBufStart, lpInsStart, lpPointer;
    D3DEXECUTEBUFFERDESC debDesc;
    size_t size;
   
	/*
     * Create an execute buffer
     */
    size = sizeof(D3DVERTEX) * NUM_VERTICES_SPOT;
    size += sizeof(D3DINSTRUCTION) * 6;
    size += sizeof(D3DSTATE) * 2;
    size += sizeof(D3DPROCESSVERTICES);
    size += sizeof(D3DTRIANGLE) * NUM_TRIANGLES_SPOT;
    memset(&debDesc, 0, sizeof(D3DEXECUTEBUFFERDESC));
    debDesc.dwSize = sizeof(D3DEXECUTEBUFFERDESC);
    debDesc.dwFlags = D3DDEB_BUFSIZE;
    debDesc.dwBufferSize = size;
    if (lpDev->CreateExecuteBuffer(&debDesc, &lpD3DExBufSpot, NULL) != D3D_OK) 
	   return FALSE;
    if (lpD3DExBufSpot->Lock( &debDesc) != D3D_OK) 
		return FALSE;
    lpBufStart = debDesc.lpData;
    memset(lpBufStart, 0, size);
    lpPointer = lpBufStart;

    /*
     * Copy vertices to execute buffer
     */
    VERTEX_DATA(&src_v[0], NUM_VERTICES_SPOT, lpPointer);
    /*
     * Setup instructions in execute buffer
     */
	
	lpInsStart = lpPointer;
    OP_PROCESS_VERTICES(1, lpPointer);
#ifdef  SCREEN_COORDINATES
// The Spot need not to be transformed
	PROCESSVERTICES_DATA(D3DPROCESSVERTICES_COPY  |
		     D3DPROCESSVERTICES_UPDATEEXTENTS, 0, NUM_VERTICES_SPOT, lpPointer);
#else
// we need only to transform the Spot (not to light it)
     PROCESSVERTICES_DATA(D3DPROCESSVERTICES_TRANSFORM, 0, NUM_VERTICES_SPOT, lpPointer);
#endif
	 OP_STATE_RENDER(2, lpPointer);
	  // the textured pointed by this hande will be loaded
	  // from the SW thread each frame
	  STATE_DATA(D3DRENDERSTATE_TEXTUREHANDLE, SPOTTextureHandle, lpPointer);
	  // we use the color key flag to get transparent texture (the spot)
	  //STATE_DATA(D3DRENDERSTATE_BLENDENABLE, FALSE, lpPointer);
	  //STATE_DATA(D3DRENDERSTATE_ALPHABLENDENABLE, TRUE, lpPointer);
	  STATE_DATA(D3DRENDERSTATE_COLORKEYENABLE, TRUE, lpPointer);
    
	/*
     * Make sure that the triangle data (not OP) will be QWORD aligned
     */
    if (QWORD_ALIGNED(lpPointer)) {
	OP_NOP(lpPointer);
    }
   /* 
   OP_TRIANGLE_LIST(NUM_TRIANGLES_SPOT, lpPointer);
	//	TRIANGLE_LIST_DATA(src_tri, NUM_TRIANGLES_SPOT, lpPointer);
    lpPointer = ((char*)lpPointer) + (sizeof(D3DTRIANGLE) * NUM_TRIANGLES_SPOT);
    OP_EXIT(lpPointer);
   */
	OP_TRIANGLE_LIST(NUM_TRIANGLES_SPOT, lpPointer);
        ((LPD3DTRIANGLE)lpPointer)->v1 = 0;
        ((LPD3DTRIANGLE)lpPointer)->v2 = 1;
        ((LPD3DTRIANGLE)lpPointer)->v3 = 2;
        ((LPD3DTRIANGLE)lpPointer)->wFlags = D3DTRIFLAG_EDGEENABLE1 | D3DTRIFLAG_EDGEENABLE3; 
		lpPointer = ((char*)lpPointer) + sizeof(D3DTRIANGLE);
	    ((LPD3DTRIANGLE)lpPointer)->v1 = 3;
        ((LPD3DTRIANGLE)lpPointer)->v2 = 2;
        ((LPD3DTRIANGLE)lpPointer)->v3 = 1;
        ((LPD3DTRIANGLE)lpPointer)->wFlags = D3DTRIFLAG_EDGEENABLE1 | D3DTRIFLAG_EDGEENABLE3;
        lpPointer = ((char*)lpPointer) + sizeof(D3DTRIANGLE);
    OP_EXIT(lpPointer);
	
	/*
     * Setup the execute data
     */
    lpD3DExBufSpot->Unlock();
    memset(&d3dExDataSpot, 0, sizeof(D3DEXECUTEDATA));
    d3dExDataSpot.dwSize = sizeof(D3DEXECUTEDATA);
    d3dExDataSpot.dwVertexCount = NUM_VERTICES_SPOT;
    d3dExDataSpot.dwInstructionOffset = (ULONG) ((char *)lpInsStart - (char *)lpBufStart);
    d3dExDataSpot.dwInstructionLength = (ULONG) ((char *)lpPointer - (char *)lpInsStart);
    lpD3DExBufSpot->SetExecuteData( &d3dExDataSpot);

    return TRUE;
}

void  moveSWPolygon()
{
   static float x_corner[4] = { -0.25f ,  0.25f ,   -0.25f  , 0.25f  } ;
   static float y_corner[4] = {  0.25f ,  0.25f ,   -0.25f  ,-0.25f  } ;
   static float swPolyPosition , u, v;
   static D3DVECTOR nxd , p , pt ;
   swPolyPosition  = tube.cameraPos  + 6.0f * (float)SPEED ; 
   SplineAtPosition( swPolyPosition, &onCurve);

   // While the camera is at Spline( t[i] ) the spot is LOCATED at Spline( t[i+6] ) . 
   // Now we have two choises for the Spot plane (one at t[i+6] and one at t[i]),
   // in the first the spot plane will not be parallel to the one spanned by the camera
   // Up and 'x' vectors and in the second it will be .
   
   //  parallel
   nxd  =CrossProduct (tube.cameraN ,  tube.cameraD ); 
   Normalize(nxd);

  for (int i = 0; i < 4; i++) {
        /*
         * v, u defines a unit vector in the plane
         * defined by vectors nxd and n.
         */
        u = x_corner[i];
        v = y_corner[i];
        /*  * x, y, z define a (~unit) vector in standard coordiante space */
        pt = u*nxd + v*tube.cameraN;
		p  = onCurve + pt;
		/*
         * Position, normals and texture coordiantes.
         */
       src_v[i].sx =  p.x ;
	   src_v[i].sy =  p.y ; 
       src_v[i].sz =  p.z ;
   }
}

void initSwSpot()
{
   // V 0 
    src_v[0].rhw = D3DVAL(1.0);
    src_v[0].color = RGBA_MAKE(255, 255, 255, 255);
    src_v[0].specular = RGB_MAKE(255,255, 255);
    src_v[0].tu = D3DVAL(0.25);
    src_v[0].tv = D3DVAL(0.25);
    // V 1
    src_v[1].rhw = D3DVAL(1.0);
    src_v[1].color = RGBA_MAKE(255, 255, 255, 255);
    src_v[1].specular = RGB_MAKE(255,255, 255);
    src_v[1].tu = D3DVAL(0.75);
    src_v[1].tv = D3DVAL(0.25);
	// V 2 
    src_v[2].rhw = D3DVAL(1.0);
    src_v[2].color = RGBA_MAKE(255, 255, 255, 255);
    src_v[2].specular = RGB_MAKE(255,255, 255);
    src_v[2].tu = D3DVAL(0.25);
    src_v[2].tv = D3DVAL(0.75);
    // V3
    src_v[3].rhw = D3DVAL(1.0);
    src_v[3].color = RGBA_MAKE(255, 255, 255, 255);
    src_v[3].specular = RGB_MAKE(255,255, 255);
    src_v[3].tu = D3DVAL(0.75);
    src_v[3].tv = D3DVAL(0.75);

#ifdef SCREEN_COORDINATES
   // V 0 
    src_v[0].sx = D3DVAL(200.0);
    src_v[0].sy = D3DVAL(180.0);
    src_v[0].sz = D3DVAL(1.0);
    // V 1
    src_v[1].sx = D3DVAL(455.0);
    src_v[1].sy = D3DVAL(180.0);
    src_v[1].sz = D3DVAL(1.0);
	// V 2 
    src_v[2].sx = D3DVAL(200.0);
    src_v[2].sy = D3DVAL(435.0);
    src_v[2].sz = D3DVAL(1.0);
    // V3
	src_v[3].sx = D3DVAL(455.0);
    src_v[3].sy = D3DVAL(435.0);
    src_v[3].sz = D3DVAL(1.0);
#endif	
	memset(&src_tri[0], 0, sizeof(D3DTRIANGLE) * NUM_TRIANGLES_SPOT);
    /* Triangle 0 */ 
    src_tri[0].v1 = 0;
    src_tri[0].v2 = 1;
	src_tri[0].v3 = 2;
    src_tri[0].wFlags = D3DTRIFLAG_EDGEENABLETRIANGLE;
    
	// Triangle 1 
	src_tri[1].v1 = 1;
    src_tri[1].v2 = 2;
	src_tri[1].v3 = 3;
    src_tri[1].wFlags = D3DTRIFLAG_EDGEENABLETRIANGLE;
}