demoii12_4.cpp

3D游戏编程大师技巧第十二章的源代码

// DEMOII12_4.CPP - Water simulation 
// READ THIS!
// To compile make sure to include DDRAW.LIB, DSOUND.LIB,
// DINPUT.LIB, DINPUT8.LIB, WINMM.LIB in the project link list, and of course 
// the C++ source modules T3DLIB1-10.CPP and the headers T3DLIB1-10.H
// be in the working directory of the compiler

// INCLUDES ///////////////////////////////////////////////

#define DEBUG_ON

#define INITGUID       // make sure al the COM interfaces are available
                       // instead of this you can include the .LIB file
                       // DXGUID.LIB
 
#define WIN32_LEAN_AND_MEAN  

#include <windows.h>   // include important windows stuff
#include <windowsx.h> 
#include <mmsystem.h>
#include <iostream.h>  // include important C/C++ stuff 
#include <conio.h> 
#include <stdlib.h>  
#include <malloc.h>  
#include <memory.h>
#include <string.h>  
#include <stdarg.h> 
#include <stdio.h>    
#include <math.h>
#include <io.h>  
#include <fcntl.h>

#include <ddraw.h>  // directX includes 
#include <dsound.h> 
#include <dmksctrl.h>  
#include <dmusici.h>
#include <dmusicc.h>
#include <dmusicf.h>
#include <dinput.h>
#include "T3DLIB1.h" // game library includes
#include "T3DLIB2.h"
#include "T3DLIB3.h"
#include "T3DLIB4.h"
#include "T3DLIB5.h"
#include "T3DLIB6.h"
#include "T3DLIB7.h"
#include "T3DLIB8.h"
#include "T3DLIB9.h"
#include "T3DLIB10.h"

// DEFINES ////////////////////////////////////////////////

// defines for windows interface
#define WINDOW_CLASS_NAME "WIN3DCLASS"  // class name
#define WINDOW_TITLE      "T3D Graphics Console Ver 2.0"
#define WINDOW_WIDTH      640     // size of window
#define WINDOW_HEIGHT     480
#define WINDOW_BPP        16      // bitdepth of window (8,16,24 etc.)
                                  // note: if windowed and not
                                  // fullscreen then bitdepth must
                                  // be same as system bitdepth
                                  // also if 8-bit the a pallete
                                  // is created and attached
   
#define WINDOWED_APP      0       // 0 not windowed, 1 windowed

// create some constants for ease of access
#define AMBIENT_LIGHT_INDEX   0   // ambient light index
#define INFINITE_LIGHT_INDEX  1   // infinite light index
#define POINT_LIGHT_INDEX     2   // point light index

// terrain defines
#define TERRAIN_WIDTH         5000 
#define TERRAIN_HEIGHT        5000
#define TERRAIN_SCALE         700
#define MAX_SPEED             20

#define PITCH_RETURN_RATE (.50)   // how fast the pitch straightens out
#define PITCH_CHANGE_RATE (.045)  // the rate that pitch changes relative to height
#define CAM_HEIGHT_SCALER (.3)    // percentage cam height changes relative to height
#define VELOCITY_SCALER   (.03)   // rate velocity changes with height
#define CAM_DECEL         (.25)   // deceleration/friction
#define WATER_LEVEL         40    // level where wave will have effect
#define WAVE_HEIGHT         25    // amplitude of modulation
#define WAVE_RATE        (0.1f)   // how fast the wave propagates

#define MAX_JETSKI_TURN           25    // maximum turn angle
#define JETSKI_TURN_RETURN_RATE   .5    // rate of return for turn
#define JETSKI_TURN_RATE           2    // turn rate
#define JETSKI_YAW_RATE           .1    // yaw rates, return, and max
#define MAX_JETSKI_YAW            10 
#define JETSKI_YAW_RETURN_RATE    .02 

// game states
#define GAME_STATE_INIT            0
#define GAME_STATE_RESTART         1
#define GAME_STATE_RUN             2
#define GAME_STATE_INTRO           3
#define GAME_STATE_PLAY            4
#define GAME_STATE_EXIT            5

// delays for introductions
#define INTRO_STATE_COUNT1 (30*7)  // 7,9,14
#define INTRO_STATE_COUNT2 (30*9)
#define INTRO_STATE_COUNT3 (30*14)

// player/jetski states
#define JETSKI_OFF                 0  
#define JETSKI_START               1 
#define JETSKI_IDLE                2
#define JETSKI_ACCEL               3 
#define JETSKI_FAST                4

// PROTOTYPES /////////////////////////////////////////////

// game console
int Game_Init(void *parms=NULL);
int Game_Shutdown(void *parms=NULL);
int Game_Main(void *parms=NULL);

// GLOBALS ////////////////////////////////////////////////

HWND main_window_handle = NULL; // save the window handle
HINSTANCE main_instance = NULL; // save the instance
char buffer[2048];              // used to print text

// initialize camera position and direction
POINT4D  cam_pos    = {0,500,-200,1};
POINT4D  cam_target = {0,0,0,1};
VECTOR4D cam_dir    = {0,0,0,1};

// all your initialization code goes here...
VECTOR4D vscale={1.0,1.0,1.0,1}, 
         vpos = {0,0,150,1}, 
         vrot = {0,0,0,1};

CAM4DV1         cam;           // the single camera
OBJECT4DV2      obj_terrain,   // the terrain object
                obj_terrain2,
                obj_player;    // the player object
RENDERLIST4DV2  rend_list;     // the render list
RGBAV1 white, gray, lightgray, black, red, green, blue; // general colors

// physical model defines play with these to change the feel of the vehicle
float gravity       = -.30;    // general gravity
float vel_y         = 0;       // the y velocity of camera/jetski
float cam_speed     = 0;       // speed of the camera/jetski
float sea_level     = -30;      // sea level of the simulation
float gclearance    = 75;      // clearance from the camera to the ground/water
float neutral_pitch = 1;       // the neutral pitch of the camera
float turn_ang      = 0; 
float jetski_yaw    = 0;

float wave_count    = 0;       // used to track wave propagation
int scroll_count    = 0;

// ambient and in game sounds
int wind_sound_id          = -1, 
    water_light_sound_id   = -1,
    water_heavy_sound_id   = -1,
    water_splash_sound_id  = -1,
    zbuffer_intro_sound_id = -1,
    zbuffer_instr_sound_id = -1, 
    jetski_start_sound_id  = -1,
    jetski_idle_sound_id   = -1,
    jetski_fast_sound_id   = -1,
    jetski_accel_sound_id  = -1,
    jetski_splash_sound_id = -1;

// game imagery assets
BOB intro_image, 
    ready_image, 
    nice_one_image;

BITMAP_IMAGE background_bmp;   // holds the background
 
ZBUFFERV1 zbuffer;             // out little z buffer

int game_state         = GAME_STATE_INIT;
int game_state_count1  = 0;

int player_state       = JETSKI_OFF;
int player_state_count1 = 0;
int enable_model_view   = 0;

RENDERCONTEXTV1 rc; // the rendering context

// FUNCTIONS //////////////////////////////////////////////

LRESULT CALLBACK WindowProc(HWND hwnd, 
						    UINT msg, 
                            WPARAM wparam, 
                            LPARAM lparam)
{
// this is the main message handler of the system
PAINTSTRUCT	ps;		   // used in WM_PAINT
HDC			hdc;	   // handle to a device context
 
// what is the message 
switch(msg)
	{	
	case WM_CREATE: 
        {
		// do initialization stuff here
		return(0);
		} break;

    case WM_PAINT:
         {
         // start painting
         hdc = BeginPaint(hwnd,&ps);

         // end painting
         EndPaint(hwnd,&ps);
         return(0);
        } break;

	case WM_DESTROY: 
		{
		// kill the application			
		PostQuitMessage(0);
		return(0);
		} break;

	default:break;

    } // end switch

// process any messages that we didn't take care of 
return (DefWindowProc(hwnd, msg, wparam, lparam));

} // end WinProc

// WINMAIN ////////////////////////////////////////////////

int WINAPI WinMain(	HINSTANCE hinstance,
					HINSTANCE hprevinstance,
					LPSTR lpcmdline,
					int ncmdshow)
{
// this is the winmain function

WNDCLASS winclass;	// this will hold the class we create
HWND	 hwnd;		// generic window handle
MSG		 msg;		// generic message
HDC      hdc;       // generic dc
PAINTSTRUCT ps;     // generic paintstruct

// first fill in the window class stucture
winclass.style			= CS_DBLCLKS | CS_OWNDC | 
                          CS_HREDRAW | CS_VREDRAW;
winclass.lpfnWndProc	= WindowProc;
winclass.cbClsExtra		= 0;
winclass.cbWndExtra		= 0;
winclass.hInstance		= hinstance;
winclass.hIcon			= LoadIcon(NULL, IDI_APPLICATION);
winclass.hCursor		= LoadCursor(NULL, IDC_ARROW);
winclass.hbrBackground	= (HBRUSH)GetStockObject(BLACK_BRUSH);
winclass.lpszMenuName	= NULL; 
winclass.lpszClassName	= WINDOW_CLASS_NAME;

// register the window class
if (!RegisterClass(&winclass))
	return(0);

// create the window, note the test to see if WINDOWED_APP is
// true to select the appropriate window flags
if (!(hwnd = CreateWindow(WINDOW_CLASS_NAME, // class
						  WINDOW_TITLE,	 // title
						  (WINDOWED_APP ? (WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION) : (WS_POPUP | WS_VISIBLE)),
					 	  0,0,	   // x,y
						  WINDOW_WIDTH,  // width
                          WINDOW_HEIGHT, // height
						  NULL,	   // handle to parent 
						  NULL,	   // handle to menu
						  hinstance,// instance
						  NULL)))	// creation parms
return(0);

// save the window handle and instance in a global
main_window_handle = hwnd;
main_instance      = hinstance;

// resize the window so that client is really width x height
if (WINDOWED_APP)
{
// now resize the window, so the client area is the actual size requested
// since there may be borders and controls if this is going to be a windowed app
// if the app is not windowed then it won't matter
RECT window_rect = {0,0,WINDOW_WIDTH-1,WINDOW_HEIGHT-1};

// make the call to adjust window_rect
AdjustWindowRectEx(&window_rect,
     GetWindowStyle(main_window_handle),
     GetMenu(main_window_handle) != NULL,  
     GetWindowExStyle(main_window_handle));

// save the global client offsets, they are needed in DDraw_Flip()
window_client_x0 = -window_rect.left;
window_client_y0 = -window_rect.top;

// now resize the window with a call to MoveWindow()
MoveWindow(main_window_handle,
           0,                                    // x position
           0,                                    // y position
           window_rect.right - window_rect.left, // width
           window_rect.bottom - window_rect.top, // height
           FALSE);

// show the window, so there's no garbage on first render
ShowWindow(main_window_handle, SW_SHOW);
} // end if windowed

// perform all game console specific initialization
Game_Init();

// disable CTRL-ALT_DEL, ALT_TAB, comment this line out 
// if it causes your system to crash
SystemParametersInfo(SPI_SCREENSAVERRUNNING, TRUE, NULL, 0);

// enter main event loop
while(1)
	{
	if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
		{ 
		// test if this is a quit
        if (msg.message == WM_QUIT)
           break;
	
		// translate any accelerator keys
		TranslateMessage(&msg);

		// send the message to the window proc
		DispatchMessage(&msg);
		} // end if
    
    // main game processing goes here
    Game_Main();

	} // end while

// shutdown game and release all resources
Game_Shutdown();

// enable CTRL-ALT_DEL, ALT_TAB, comment this line out 
// if it causes your system to crash
SystemParametersInfo(SPI_SCREENSAVERRUNNING, FALSE, NULL, 0);

// return to Windows like this
return(msg.wParam);

} // end WinMain

// T3D II GAME PROGRAMMING CONSOLE FUNCTIONS ////////////////

int Game_Init(void *parms)
{
// this function is where you do all the initialization 
// for your game

int index; // looping var

// start up DirectDraw (replace the parms as you desire)
DDraw_Init2(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_BPP, WINDOWED_APP,0);

// initialize directinput
DInput_Init();

// acquire the keyboard 
DInput_Init_Keyboard();

// add calls to acquire other directinput devices here...

// initialize directsound and directmusic
DSound_Init();
DMusic_Init();

// hide the mouse
if (!WINDOWED_APP)
    ShowCursor(FALSE);

// seed random number generator
srand(Start_Clock()); 

Open_Error_File("ERROR.TXT");

// initialize math engine
Build_Sin_Cos_Tables();

// initialize the camera with 90 FOV, normalized coordinates
Init_CAM4DV1(&cam,      // the camera object
             CAM_MODEL_EULER, // the euler model
             &cam_pos,  // initial camera position
             &cam_dir,  // initial camera angles
             &cam_target,      // no target
             30.0,        // near and far clipping planes
             12000.0,
             90.0,      // field of view in degrees
             WINDOW_WIDTH,   // size of final screen viewport
             WINDOW_HEIGHT); 

// position the terrain at 0,0,0
VECTOR4D terrain_pos = {0,0,0,0};

#if 1
// generate land terrain
Generate_Terrain2_OBJECT4DV2(&obj_terrain,            // pointer to object
                            TERRAIN_WIDTH,           // width in world coords on x-axis
                            TERRAIN_HEIGHT,          // height (length) in world coords on z-axis
                            TERRAIN_SCALE,           // vertical scale of terrain
                            "water_track_height_04.bmp",  // filename of height bitmap encoded in 256 colors
                            "water_track_color_03.bmp",   // filename of texture map
                             RGB16Bit(255,255,255),  // color of terrain if no texture        
                             &terrain_pos,           // initial position
                             NULL,                   // initial rotations
                             POLY4DV2_ATTR_RGB16  
                             //| POLY4DV2_ATTR_SHADE_MODE_CONSTANT
                             // | POLY4DV2_ATTR_SHADE_MODE_FLAT 
                              | POLY4DV2_ATTR_SHADE_MODE_GOURAUD
                             | POLY4DV2_ATTR_SHADE_MODE_TEXTURE,
                             50, 150);

#endif

#if 1
// generate seabottom terrain
Generate_Terrain2_OBJECT4DV2(&obj_terrain2,            // pointer to object
                            TERRAIN_WIDTH,           // width in world coords on x-axis
                            TERRAIN_HEIGHT,          // height (length) in world coords on z-axis
                            1*TERRAIN_SCALE,           // vertical scale of terrain
                            "heightmap02.bmp",  // filename of height bitmap encoded in 256 colors
                            "seabottom_01.bmp",   // filename of texture map
                             RGB16Bit(255,255,255),  // color of terrain if no texture        
                             &terrain_pos,           // initial position
                             NULL,                   // initial rotations
                             POLY4DV2_ATTR_RGB16  
                             // | POLY4DV2_ATTR_SHADE_MODE_CONSTANT
                             | POLY4DV2_ATTR_SHADE_MODE_FLAT 
                             //| POLY4DV2_ATTR_SHADE_MODE_GOURAUD
                             | POLY4DV2_ATTR_SHADE_MODE_TEXTURE,
                             -1, -1);

#endif



// we are getting divide by zero errors due to degenerate triangles
// after projection, this is a problem with the rasterizer that we will
// fix later, but if we add a random bias to all y components of each vertice
// is fixes the problem, its a hack, but hey no one is perfect :)
for (int v = 0; v < obj_terrain.num_vertices; v++)
    obj_terrain.vlist_local[v].y+= ((float)RAND_RANGE(-5,5))/10;
 

// load the jetski model for player
VECTOR4D_INITXYZ(&vscale,17.5,17.50,17.50);  

Load_OBJECT4DV2_COB2(&obj_player, "jetski06.cob",  
                   &vscale, &vpos, &vrot, VERTEX_FLAGS_SWAP_YZ  |
                                          VERTEX_FLAGS_TRANSFORM_LOCAL  | VERTEX_FLAGS_INVERT_TEXTURE_V
                                               /* VERTEX_FLAGS_TRANSFORM_LOCAL_WORLD*/ );
 

// set up lights
Reset_Lights_LIGHTV2(lights2, MAX_LIGHTS);