我要发帖 回复

正式会员

2

主题

21

积分

0

专家分

:

私信
发表时间 : 2010-2-7 13:16:42 | 浏览 : 1160    评论 : 2
程序编译没有错误

配置文件的问题应该解决了

运行的时候,只有带有vega的黑屏出现一下,然后隔了几秒就消失了,留下的那个类似dos的黑屏里写着“press any key to continue"

实在不知道是哪错了……求高手帮忙啊!!

最近VR访客

风飞的小孩 评论于2010-2-8 13:33:03
本帖最后由 风飞的小孩 于 2010-2-8 02:38 PM 编辑

这是我的程序……
// demo2.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdlib.h>
#include <vg.h>
#include <vgfx.h>
#include <vgperf.h>
#include <pf.h>
#include <string.h>
#include <time.h>

#define ORIGINX 2500.0f
#define        ORIGINY 2500.0f
#define        ZSTART        500.0f
#define        RADIUS        1000.0f
#define        H_RATE        0.25f
#define        Z_RATE        3.5f
#define        MISSILE1_PATH        "./missile1.path"
#define        MISSILE1_NAV        "./missile1.nav"
#define        MISSILE2_PATH        "./missile2.path"
#define        MISSILE2_NAV        "./missile2.nav"
#define        HELITOE2C_PATH        "./helitoe2c.path"
#define HELITOE2C_NAV        "./helitoe2c.nav"

static void DrawInfoCallBack(vgCommon *chan,void *udata);
static void stateHandler(void);
static void computeVVec(float *vv,vgPosition *pos);
static int randomNum(int number);//获取随机整数值

static float e2c_radius=1000.0f;//预警机巡航半径
static int state=0;//仿真运行状态
static int m1launchable=0;//导弹1是否可发射
static int m2launchable=0;//导弹2是否可发射
static int e2cDownable=0;//E2C是否可失事
static int m1used=0;//导弹1是否已发射
static int m2used=0;//导弹2是否已发射
static float startTime=0;//计时起始时间
static float timeNow=0;//计时间隔时间
static float deltaFrameTime=0.0167f;//帧渲染间隔时间

void main(void)
{
        static vgObserver *obs;
        static vgChannel *chan;
        static vgScene *scene;
        static vgObject *m1,*m2;
        static vgPlayer *tank,*heli,*missile1,*missile2;
        static vgPlayer *e2c,*tank_crater,*e2c_crater;
        static vgIsector *fortank,*formissile1,*formissile2;
        static vgIsector *fore2c,*forheli,*forcrater;
        static vgPosition *pos,*e2c_pos,*heli_pos,*missile_pos,*target_pos;
        static vgFx *h_blade1,*h_blade2;
        static vgFx *e_blade1,*e_blade2,*e_trail1,*e_trail2;
        static vgFx *e_airhit,*e_engsmoke,*e_engburn,*e_flash;
        static vgFx *e_fire,*e_smoke,*e_explode,*e_debris;
        static vgFx *m1_flame,*m1_trail,*m2_flame,*m2_trail;
        static vgFx *t_flash,*t_explode1,*t_debris1,*t_smoke;
        static vgFx *t_flame,*t_explode2,*t_debris2,*t_fire;
        static vgPath *tank_path,*tankupdown_path,*heli_path;
        static vgSplineNavigator *tank_nav,*tankupdown_nav,*heli_nav;
        static vgPath *missile1_path,*missile2_path,*helitoe2c_path;
        static vgSplineNavigator *missile1_nav,*missile2_nav,*helitoe2c_nav;
        static VelocityMarker vm;
        static float x,y,z;
        static float h=0.0f,p=0.0f,r=-25.0f;
        static float e2cBspeed=1.0f;//预警机螺旋桨转速
        static float heliBspeed=0.0f;//直升机螺旋桨转速
        static float vvec[4],e2cISresult[4],m1ISresult[4],m2ISresult[4];
        static float hsin,hcos;
        static float psin,pcos;
        static int tankhitted=0;//坦克状态标志
        static int e2ccrashed=0;//预警机是否坠毁
        static int i=0;
        static int m,n,idx;
        static float tx,ty,tz,th,tp,tr;
        static float hx,hy,hz,hh,hp,hr;
        static float crashed_x,crashed_y,crashed_z;

        vgInitSys();
        vgInitFx();
        vgDefineSys("demo.adf");
        vgConfigSys();

        //初始化Vega变量
        obs=vgGetObserv(0);
        chan=vgGetObservChan(obs,0);
        scene=vgGetScene(0);
        m1=vgFindObj("Missile1");
        m2=vgFindObj("Missile2");
        tank=vgFindPlyr("p_Tank");
        heli=vgFindPlyr("p_Heli");
        missile1=vgFindPlyr("p_Missile1");
        missile2=vgFindPlyr("p_Missile2");
        e2c=vgFindPlyr("p_E2C");
        tank_crater=vgFindPlyr("p_Tank_Crater");
        e2c_crater=vgFindPlyr("p_E2C_Crater");

        fortank=vgFindIsect("forTank");
        fore2c=vgFindIsect("forE2C");
        forheli=vgFindIsect("forHeli");
        formissile1=vgFindIsect("forMissile1");
        formissile2=vgFindIsect("forMissile2");
        forcrater=vgFindIsect("forCrater");

        tank_path=vgFindPath("tank_use");
        tank_nav=vgFindSplineNavigator("tank_use");
        tankupdown_path=vgFindPath("tank_up_down");
        tankupdown_nav=vgFindSplineNavigator("tank_up_down");
        heli_path=vgFindPath("heli_use");
        heli_nav=vgFindSplineNavigator("heli_use");

        h_blade1=vgFindFx("H_blade1");
        h_blade2=vgFindFx("H_blade2");
        e_blade1=vgFindFx("E_blade1");
        e_blade2=vgFindFx("E_blade2");
        e_trail1=vgFindFx("E_trail1");
        e_trail2=vgFindFx("E_trail2");
        e_airhit=vgFindFx("E_airhit");
        e_engsmoke=vgFindFx("E_engsmoke");
        e_engburn=vgFindFx("E_engburn");
        e_flash=vgFindFx("E_flash");
        e_explode=vgFindFx("E_explode");
        e_debris=vgFindFx("E_debris");
        e_fire=vgFindFx("E_fire");
        e_smoke=vgFindFx("E_smoke");
        m1_trail=vgFindFx("M1_trail");
        m1_flame=vgFindFx("M1_flame");
        m2_trail=vgFindFx("M2_trail");
        m2_flame=vgFindFx("M2_flame");
        t_flash=vgFindFx("T_flash");
        t_explode1=vgFindFx("T_explode1");
        t_debris1=vgFindFx("T_debris1");
        t_flame=vgFindFx("T_flame");
        t_fire=vgFindFx("T_fire");
        t_explode2=vgFindFx("T_explode2");
        t_debris2=vgFindFx("T_debris2");
        t_smoke=vgFindFx("T_smoke");

        //注册回调函数
        vgAddFunc(chan,VGCHAN_POSTDRAW,DrawInfoCallBack,NULL);
        startTime=vgGetTime();

        while(1)
        {
                vgSyncFrame();
                vgFrame();
                //处理输入事件
                stateHandler();
                //判断直升机状态
                if(vgGetIsectResult(fore2c,VGIS_GETLOS,e2cISresult))
                {
                        e2ccrashed=1;//E2C预警机坠地
                        crashed_x=e2cISresult[1];
                        crashed_y=e2cISresult[2];
                        crashed_z=e2cISresult[3];
                }
                //控制预警机飞行状态
                if(!e2c_pos)
                        e2c_pos=vgNewPos();
                vgPosVec(e2c_pos,x,y,z,h,p,r);
                vgPos(e2c,e2c_pos);
                computeVVec(&vvec[1],e2c_pos);
                if(!e2ccrashed && z>0.0f)
                {
                        h+=H_RATE;
                        if(h>360.0f)
                                h-=360.0f;
                        vgGetSinCos(h,&hsin,&hcos);
                        vgGetSinCos(p,&psin,&pcos);
                        x=ORIGINX+e2c_radius*hcos;
                        y=ORIGINY+e2c_radius*hsin;
                        z+=Z_RATE*psin;
                }
                //计算时间间隔
                timeNow=vgGetTime()-startTime;

                switch(state)
                {
                case 0://初始状态
                        //初始化E2C预警机位姿
                        z=ZSTART;
                        p=0.0f;
                        r=-25.0f;
                        //设置视点
                        vgProp(obs,VGOBS_TETHERSTATE,VGOBS_FIXED);
                        vgProp(obs,VGOBS_LOOKAT_TARGET,VGOBS_L_NONE);
                        vgObservPlyr(obs,e2c);
                        pos=vgNewPos();
                        vgPosVec(pos,100,25,5,100,-10,0);
                        vgObservTetherPos(obs,pos);
                        //设置直升机和坦克的初始位置
                        vgProp(tankupdown_nav,VGSPLINENAV_CURRENT_INDEX,0);
                        vgPosVec(pos,2944.0f,3215.0f,17.828f,-180,0,0);
                        vgPos(heli,pos);
                        vgPosVec(pos,2208,1035,0,0,0,0);
                        vgPos(tank,pos);
                        vgPosVec(pos,0,0,0,0,0,0);
                        vgPos(tank_crater,pos);
                        vgPos(e2c_crater,pos);
                        vgDelPos(pos);
                        //设置特效状态
                        e2cBspeed=1.0f;
                        vgProp(e_blade1,VGFX_BSPEED,e2cBspeed);
                        heliBspeed=0.0f;
                        vgProp(h_blade1,VGFX_BSPEED,e2cBspeed);
                        vgProp(h_blade2,VGFX_BSPEED,e2cBspeed);
                        vgProp(e_blade1,VGFX_STATE,VG_ON);
                        vgProp(e_blade2,VGFX_STATE,VG_ON);
                        vgProp(e_trail1,VGFX_STATE,VG_ON);
                        vgProp(e_trail1,VGFX_STATE,VG_ON);
                        vgFxTime(e_trail1,VGFX_STARTTIME,VGFX_NOW);
                        vgFxTime(e_trail2,VGFX_STARTTIME,VGFX_NOW);
                        startTime=vgGetTime();
                        state=1;
                        break;

                case 1://坦克开始行动
                        if(timeNow>10.0f+randomNum(5))
                        {
                                vgProp(tank_nav,VGSPLINENAV_CURRENT_INDEX,0);
                                startTime=vgGetTime();
                                state=2;
                        }
                        break;
                case 2://锁定坦克
                        vgProp(tank_nav,VGCOMMON_ENABLED,VG_ON);
                        vgProp(tank,VGPLYR_SPLINE_NAVIGATOR,VG_ON);
                        vgPlyrNav(tank,(vgNavigator*)tank_nav);
                        vgProp(obs,VGOBS_TETHERSTATE,VGOBS_FIXED);
                        pos=vgNewPos();
                        vgPosVec(pos,0,-8,5,0,-10,0);
                        vgObservTetherPos(obs,pos);
                        vgObservPlyr(obs,tank);
                        vgDelPos(pos);
                        if(timeNow>20.0f+randomNum(5))
                        {
                                vgProp(obs,VGOBS_TETHERSTATE,VGOBS_FIXED);
                                pos=vgNewPos();
                                vgPosVec(pos,0,0,0,0,0,0);
                                vgObservTetherPos(obs,pos);
                                vgObservPlyr(obs,e2c);
                                vgDelPos(pos);
                                vgProp(obs,VGOBS_LOOKAT_TARGET,VGOBS_L_PLYR);
                                vgObservLookatPlyr(obs,tank);
                                startTime=vgGetTime();
                                state=3;
                        }
                        break;
                case 3://监视坦克行动
                        if(i>-300)
                        {
                                pos=vgNewPos();
                                vgPosVec(pos,0,0,i,0,0,0);
                                vgObservTetherPos(obs,pos);
                                vgObservPlyr(obs,e2c);
                                vgDelPos(pos);
                                i--;
                        }
                        if(timeNow>15.0f+randomNum(5))
                        {
                                startTime=vgGetTime();
                                state=4;
                        }
                        break;
                case 4://直升机启动
                        vgProp(obs,VGOBS_LOOKAT_TARGET,VGOBS_L_NONE);
                        vgProp(obs,VGOBS_TETHERSTATE,VGOBS_FIXED);
                        pos=vgNewPos();
                        vgPosVec(pos,50.0f,0.0f,5.0f,90,-10,0);
                        vgObservTetherPos(obs,pos);
                        vgObservPlyr(obs,heli);
                        vgDelPos(pos);
                        vgProp(h_blade1,VGFX_STATE,VG_ON);
                        vgProp(h_blade2,VGFX_STATE,VG_ON);
                        if(heliBspeed<1.0f)
                                heliBspeed+=0.0025f;
                        else
                        {
                                vgProp(heli_nav,VGSPLINENAV_CURRENT_INDEX,0);
                                startTime=vgGetTime();
                                state=5;
                        }
                        vgProp(h_blade1,VGFX_BSPEED,heliBspeed);
                        vgProp(h_blade2,VGFX_BSPEED,heliBspeed);
                        break;
                case 5://直升机行动
                        vgProp(heli_nav,VGCOMMON_ENABLED,VG_ON);
                        vgProp(heli,VGPLYR_SPLINE_NAVIGATOR,VG_ON);
                        vgProp(heli_nav,VGSPLINENAV_START_INDEX,0);
                        vgProp(heli_nav,VGSPLINENAV_STOP_AT_END,VG_ON);
                        vgPlyrNav(heli,(vgNavigator*)heli_nav);
                        vgProp(obs,VGOBS_TETHERSTATE,VGOBS_SPIN);
                        vgObservPlyr(obs,heli);
                        vgProp(obs,VGOBS_SPINRAD,80);
                        vgProp(obs,VGOBS_SPINDELTA,0.5);
                        vgProp(obs,VGOBS_SPINELEV,20);

                        if(vgGetProp(tank_nav,VGSPLINENAV_CURRENT_INDEX)==vgGetProp(tank_path,VGPATH_NUM_CTRLPTS)-1)
                        {
                                m1launchable=1;
                                m2launchable=2;
                        }
                        break;
                case 6://发射第一枚导弹
                        //创建导弹路径
                        missile1_path=vgNewPath(MISSILE1_PATH,NULL);
                        vgName(missile1_path,"M1_path");
                        missile_pos=vgNewPos();
                        target_pos=vgNewPos();
                        vgGetWCSPos(missile1,missile_pos);
                        vgGetPosVec(missile_pos,&tx,&ty,&tz,&th,&tp,&tr);
                        vgProp(missile1,VGPLYR_CSREF,VGPLYR_ABSOLUTE);
                        vgPosVec(missile_pos,tx,ty,tz,0,0,0);
                        vgPos(missile1,missile_pos);
                        vgGetPos(tank,target_pos);
                        vgGetPosVec(target_pos,&tx,&ty,&tz,&th,&tp,&tr);
                        vgPosVec(target_pos,tx,ty,tz,0,0,0);
                        vgPathAddCtrlPointPos(missile1_path,missile_pos);
                        vgPathAddCtrlPointPos(missile1_path,target_pos);
                        vgDelPos(missile_pos);
                        vgDelPos(target_pos);
                        missile1_nav=vgNewSplineNavigator(MISSILE1_NAV,missile1_path);
                        vgName(missile1_nav,"M1_nav");
                        vgProp(missile1_nav,VGCOMMON_ENABLED,VG_ON);
                        vgProp(missile1_nav,VGSPLINENAV_START_INDEX,0);
                        vgProp(missile1_nav,VGSPLINENAV_RENDER,VG_OFF);
                        vgNavigatorAddMarker(missile1_nav,0,VGSPLINENAV_LINEAR,0,NULL,0);
                        vgNavigatorAddMarker(missile1_nav,0,VGSPLINENAV_ABSOLUTE_HPR,VG_FALSE,NULL,0);
                        vm.beginSpeed=40.0f;
                        vm.endSpeed=100.0f;
                        vgNavigatorAddMarker(missile1_nav,0,VGSPLINENAV_VELOCITIES,0,&vm,sizeof(VelocityMarker));
                        vgNavigatorAddMarker(missile1_nav,1,VGNAV_EMPTY,0,NULL,0);
                        vgMakeSplineNavigator(missile1_nav);
                        //控制导弹特效
                        vgProp(m1_flame,VGFX_STATE,VG_ON);
                        vgProp(m1_trail,VGFX_STATE,VG_ON);
                        vgProp(m1_flame,VGFX_DURATION,VGFX_ALWAYS);
                        vgProp(m1_trail,VGFX_DURATION,VGFX_ALWAYS);
                        vgFxTime(m1_flame,VGFX_STARTTIME,VGFX_NOW);
                        vgFxTime(m1_trail,VGFX_STARTTIME,VGFX_NOW);
                        vgProp(missile1,VGPLYR_SPLINE_NAVIGATOR,VG_ON);
                        //控制观察者状态
                        vgPlyrNav(missile1,(vgNavigator*)missile1_nav);
                        vgProp(obs,VGOBS_TETHERSTATE,VGOBS_FIXED);
                        pos=vgNewPos();
                        vgPosVec(pos,0,-25,5,0,-15,0);
                        vgObservTetherPos(obs,pos);
                        vgObservPlyr(obs,missile1);
                        vgDelPos(pos);

                        m1launchable=0;
                        startTime=vgGetTime();
                        state=10;
                        break;

                case 7://发射第二枚导弹
                        //创建导弹路径
                        missile2_path=vgNewPath(MISSILE2_PATH,NULL);
                        vgName(missile2_path,"M2_path");
                        missile_pos=vgNewPos();
                        target_pos=vgNewPos();
                        vgGetWCSPos(missile2,missile_pos);
                        vgGetPosVec(missile_pos,&tx,&ty,&tz,&th,&tp,&tr);
                        vgProp(missile2,VGPLYR_CSREF,VGPLYR_ABSOLUTE);
                        vgPosVec(missile_pos,tx,ty,tz,0,0,0);
                        vgPos(missile2,missile_pos);
                        vgGetPos(tank,target_pos);
                        vgGetPosVec(target_pos,&tx,&ty,&tz,&th,&tp,&tr);
                        vgPosVec(target_pos,tx,ty,tz,0,0,0);
                        vgPathAddCtrlPointPos(missile2_path,missile_pos);
                        vgPathAddCtrlPointPos(missile2_path,target_pos);
                        vgDelPos(missile_pos);
                        vgDelPos(target_pos);
                        missile2_nav=vgNewSplineNavigator(MISSILE2_NAV,missile2_path);
                        vgName(missile2_nav,"M2_nav");
                        vgProp(missile2_nav,VGCOMMON_ENABLED,VG_ON);
                        vgProp(missile1_nav,VGSPLINENAV_START_INDEX,0);
                        vgProp(missile2_nav,VGSPLINENAV_RENDER,VG_OFF);
                        vgNavigatorAddMarker(missile2_nav,0,VGSPLINENAV_LINEAR,0,NULL,0);
                        vgNavigatorAddMarker(missile2_nav,0,VGSPLINENAV_ABSOLUTE_HPR,VG_FALSE,NULL,0);
                        vm.beginSpeed=40.0f;
                        vm.endSpeed=100.0f;
                        vgNavigatorAddMarker(missile2_nav,0,VGSPLINENAV_VELOCITIES,0,&vm,sizeof(VelocityMarker));
                        vgNavigatorAddMarker(missile2_nav,1,VGNAV_EMPTY,0,NULL,0);
                        vgMakeSplineNavigator(missile2_nav);
                        //控制导弹特效
                        vgProp(m2_flame,VGFX_STATE,VG_ON);
                        vgProp(m2_trail,VGFX_STATE,VG_ON);
                        vgProp(m2_flame,VGFX_DURATION,VGFX_ALWAYS);
                        vgProp(m2_trail,VGFX_DURATION,VGFX_ALWAYS);
                        vgFxTime(m2_flame,VGFX_STARTTIME,VGFX_NOW);
                        vgFxTime(m2_trail,VGFX_STARTTIME,VGFX_NOW);
                        vgProp(missile2,VGPLYR_SPLINE_NAVIGATOR,VG_ON);
                        //控制观察者状态
                        vgPlyrNav(missile2,(vgNavigator*)missile2_nav);
                        vgProp(obs,VGOBS_TETHERSTATE,VGOBS_FIXED);
                        pos=vgNewPos();
                        vgPosVec(pos,0,-25,5,0,-15,0);
                        vgObservTetherPos(obs,pos);
                        vgObservPlyr(obs,missile1);
                        vgDelPos(pos);
                        vgObservPlyr(obs,missile2);

                        m2launchable=0;
                        startTime=vgGetTime();
                        state=10;
                        break;
                case 8://坦克被第一次击中
                        vgProp(obs,VGOBS_TETHERSTATE,VGOBS_SPIN);
                        vgObservPlyr(obs,tank);
                        vgProp(obs,VGOBS_SPINRAD,100);
                        vgProp(obs,VGOBS_SPINDELTA,0.5);
                        vgProp(obs,VGOBS_SPINELEV,20);
                        pos=vgNewPos();
                        vgGetPos(tank,pos);
                        vgPos(tank_crater,pos);
                        vgProp(tank,VGPLYR_SPLINE_NAVIGATOR,VG_OFF);
                        vgPos(tank,pos);
                        vgDelPos(pos);
                        //第一次被击中特效
                        vgProp(t_flash,VGFX_STATE,VG_ON);
                        vgProp(t_explode1,VGFX_STATE,VG_ON);
                        vgProp(t_debris1,VGFX_STATE,VG_ON);
                        vgProp(t_flame,VGFX_STATE,VG_ON);
                        vgProp(t_smoke,VGFX_STATE,VG_ON);
                        vgProp(t_flame,VGFX_DURATION,VGFX_ALWAYS);
                        vgProp(t_smoke,VGFX_DURATION,VGFX_ALWAYS);
                        vgProp(t_explode1,VGFX_AUTO,VG_OFF);
                        vgProp(t_debris1,VGFX_AUTO,VG_OFF);
                        vgFxTime(t_flash,VGFX_STARTTIME,VGFX_NOW);
                        vgFxTime(t_explode1,VGFX_STARTTIME,VGFX_NOW);
                        vgFxTime(t_debris1,VGFX_STARTTIME,VGFX_NOW);
                        vgFxTime(t_flame,VGFX_STARTTIME,VGFX_NOW);
                        vgFxTime(t_smoke,VGFX_STARTTIME,VGFX_NOW);

                        startTime=vgGetTime();
                        tankhitted++;
                        state=10;
                        break;

                case 9://坦克被炸翻
                        vgProp(obs,VGOBS_TETHERSTATE,VGOBS_SPIN);
                        vgObservPlyr(obs,tank);
                        vgProp(obs,VGOBS_SPINRAD,60);
                        vgProp(obs,VGOBS_SPINDELTA,0.5);
                        vgProp(obs,VGOBS_SPINELEV,12);
                        vgRemPlyrIsect(tank,fortank);
                        vgProp(tankupdown_nav,VGCOMMON_ENABLED,VG_ON);
                        vgProp(tank,VGPLYR_SPLINE_NAVIGATOR,VG_ON);
                        vgPlyrNav(tank,(vgNavigator*)tankupdown_nav);
                        //第二次被击中特效
                        vgProp(t_explode2,VGFX_STATE,VG_ON);
                        vgProp(t_debris2,VGFX_STATE,VG_ON);
                        vgProp(t_fire,VGFX_STATE,VG_ON);
                        vgProp(t_fire,VGFX_DURATION,VGFX_ALWAYS);
                        vgFxTime(t_explode2,VGFX_STARTTIME,VGFX_NOW);
                        vgFxTime(t_debris2,VGFX_STARTTIME,VGFX_NOW);
                        vgFxTime(t_fire,VGFX_STARTTIME,VGFX_NOW);

                        startTime=vgGetTime();
                        tankhitted++;
                        state=10;
                        break;
                case 10://判断坦克状态
                        if(!m1used)
                        {
                                if(vgGetIsectResult(formissile1,VGIS_GETLOS,m1ISresult))
                                {
                                        tankhitted++;
                                        m1used=1;
                                }
                        }
                        if(!m2used)
                        {
                                if(vgGetIsectResult(formissile2,VGIS_GETLOS,m2ISresult))
                                {
                                        tankhitted++;
                                        m2used=1;
                                }
                        }
                        if(tankhitted==1)
                                state=8;//坦克被第一枚导弹击中
                        if(tankhitted==3)
                        {
                                //控制导弹特效
                                vgProp(m1_flame,VGFX_STATE,VG_OFF);
                                vgProp(m1_trail,VGFX_STATE,VG_OFF);
                                vgProp(m2_flame,VGFX_STATE,VG_OFF);
                                vgProp(m2_trail,VGFX_STATE,VG_OFF);
                                //移除导弹
                                vgRemSceneObj(scene,m1);
                                vgRemSceneObj(scene,m2);
                                state=0;
                        }
                        if((tankhitted==4)&&(timeNow>5.0f))
                        {
                                vgProp(obs,VGOBS_TETHERSTATE,VGOBS_SPIN);
                                vgProp(obs,VGOBS_LOOKAT_TARGET,VGOBS_L_NONE);
                                vgObservPlyr(obs,e2c);
                                vgProp(obs,VGOBS_SPINRAD,100);
                                vgProp(obs,VGOBS_SPINDELTA,0.25);
                                vgProp(obs,VGOBS_SPINELEV,25);
                                e2cDownable=1;
                                startTime=vgGetTime();
                        }
                        break;

                case 11://预警机发动机失效
                        vgProp(obs,VGOBS_TETHERSTATE,VGOBS_SPIN);
                        vgObservPlyr(obs,e2c);
                        vgProp(obs,VGOBS_SPINRAD,60);
                        vgProp(obs,VGOBS_SPINDELTA,0.25);
                        vgProp(obs,VGOBS_SPINELEV,30);

                        vgProp(e_trail1,VGFX_DURATION,vgGetTime()-vgGetFxTime(e_trail1,VGFX_STARTTIME)+1.0);
                        vgProp(e_trail1,VGFX_FADEDUR,1.0);

                        vgProp(e_airhit,VGFX_STATE,VG_ON);
                        vgProp(e_engburn,VGFX_STATE,VG_ON);
                        vgProp(e_engsmoke,VGFX_STATE,VG_ON);
                        vgProp(e_engburn,VGFX_DURATION,VGFX_ALWAYS);
                        vgProp(e_engsmoke,VGFX_DURATION,VGFX_ALWAYS);
                        vgProp(e_airhit,VGFX_DURATION,VGFX_NOW);
                        vgProp(e_engburn,VGFX_DURATION,VGFX_NOW);
                        vgProp(e_engsmoke,VGFX_DURATION,VGFX_NOW);
                        e2c_radius=800.0f;
                        e2cDownable=0;
                        state=12;
                        break;

                case 12://预警机发动机着火
                        if(e2ccrashed)
                        {
                                state=13;
                                break;
                        }
                        if(e2cBspeed>0.0f)
                                e2cBspeed-=0.025f;
                        vgProp(e_blade1,VGFX_BSPEED,e2cBspeed);
                        //设置自定义特效的速度矢量
                        vvec[0]=0.0f;
                        vvec[1]*=(deltaFrameTime*5.0f);
                        vvec[2]*=(deltaFrameTime*5.0f);
                        vvec[3]*=(deltaFrameTime*5.0f);
                        vgAttrList(e_engburn,VGFX_VVECTOR,vvec,1);
                        vgAttrList(e_engsmoke,VGFX_VVECTOR,vvec,1);

                        p-=H_RATE;
                        if(p<-60.0f)
                                p=-60.0f;
                        r-=H_RATE;
                        break;

                case 13://预警机坠地爆炸
                        vgProp(obs,VGOBS_SPINRAD,100);
                        vgProp(obs,VGOBS_SPINDELTA,0.5);
                        vgProp(obs,VGOBS_SPINELEV,25);
                        pos=vgNewPos();
                        vgGetPos(e2c,pos);
                        vgPos(e2c_crater,pos);
                        vgDelPos(pos);

                        vgProp(e_engburn,VGFX_DURATION,vgGetTime()-vgGetFxTime(e_engburn,VGFX_STARTTIME)+vgGetProp(e_engburn,VGFX_LCYCLE));
                        vgProp(e_engsmoke,VGFX_DURATION,vgGetTime()-vgGetFxTime(e_engsmoke,VGFX_STARTTIME)+vgGetProp(e_engsmoke,VGFX_LCYCLE));
                        vgProp(e_trail2,VGFX_DURATION,vgGetTime()-vgGetFxTime(e_trail2,VGFX_STARTTIME)+vgGetProp(e_engburn,2.0));
                        vgProp(e_trail2,VGFX_FADEDUR,2.0);
                        vgProp(e_blade1,VGFX_STATE,VG_OFF);
                        vgProp(e_blade2,VGFX_STATE,VG_OFF);
                        //定义直升机救援路径
                        vgProp(heli_nav,VGCOMMON_ENABLED,VG_OFF);
                        helitoe2c_path=vgNewPath(HELITOE2C_PATH,NULL);
                        vgName(helitoe2c_path,"HtoE_path");
                        heli_pos=vgNewPos();
                        e2c_pos=vgNewPos();
                        pos=vgNewPos();
                        vgGetPos(heli,heli_pos);
                        vgGetPosVec(heli_pos,&tx,&ty,&tz,&th,&tp,&tr);
                        vgPos(heli,heli_pos);
                        vgPosVec(heli_pos,tx,ty,tz,0,0,0);
                        vgGetPos(e2c,e2c_pos);
                        vgGetPosVec(e2c_pos,&hx,&hy,&hz,&hh,&hp,&hr);
                        vgPosVec(pos,hx-25.0f,hy-25.0f,hz,0,0,0);
                        vgPosVec(e2c_pos,crashed_x-25.0f,crashed_y-25.0f,crashed_z+4.0f,0,0,0);
                        vgPathAddCtrlPointPos(helitoe2c_path,heli_pos);
                        vgPathAddCtrlPointPos(helitoe2c_path,pos);
                        vgPathAddCtrlPointPos(helitoe2c_path,e2c_pos);
                        vgDelPos(heli_pos);
                        vgDelPos(pos);
                        vgDelPos(e2c_pos);

                        helitoe2c_nav=vgNewSplineNavigator(HELITOE2C_NAV,helitoe2c_path);
                        vgName(helitoe2c_nav,"HtoE_nav");
                        vgProp(helitoe2c_nav,VGSPLINENAV_START_INDEX,0);
                        vgProp(helitoe2c_nav,VGSPLINENAV_RENDER,VG_OFF);
                        vgNavigatorAddMarker(helitoe2c_nav,0,VGSPLINENAV_LINEAR,0,NULL,0);
                        vgNavigatorAddMarker(helitoe2c_nav,0,VGSPLINENAV_ABSOLUTE_HPR,VG_FALSE,NULL,0);
                        vgNavigatorAddMarker(helitoe2c_nav,0,VGSPLINENAV_VELOCITY,40,NULL,0);
                        vm.beginSpeed=40.0f;
                        vm.endSpeed=0.0f;
                        vgNavigatorAddMarker(helitoe2c_nav,1,VGSPLINENAV_VELOCITIES,0,&vm,sizeof(VelocityMarker));
                        vgNavigatorAddMarker(helitoe2c_nav,1,VGSPLINENAV_ABSOLUTE_HPR,VG_TRUE,NULL,0);
                        vgNavigatorAddMarker(helitoe2c_nav,2,VGNAV_EMPTY,0,NULL,0);
                        vgMakeSplineNavigator(helitoe2c_nav);
                        vgProp(helitoe2c_nav,VGSPLINENAV_CURRENT_INDEX,0);
                        vgProp(helitoe2c_nav,VGCOMMON_ENABLED,VG_OFF);
                        startTime=vgGetTime();
                        state=14;
                        break;

                case 14://直升机赶往预警机残骸处营救
                        if(timeNow>5.0f)
                        {
                                vgPlyrNav(heli,(vgNavigator*)helitoe2c_nav);
                                pos=vgNewPos();
                                vgPosVec(pos,0.0f,-50.0f,10.0f,0,-10,0);
                                vgObservTetherPos(obs,pos);
                                vgDelPos(pos);
                                vgProp(pos,VGOBS_TETHERSTATE,VGOBS_FIXED);
                                vgProp(helitoe2c_nav,VGCOMMON_ENABLED,VG_ON);
                                vgObservPlyr(obs,heli);
                        }
                        if(vgGetProp(helitoe2c_nav,VGSPLINENAV_CURRENT_INDEX)==2)
                        {
                                startTime=vgGetTime();
                                state=15;
                        }
                        break;

                case 15://直升机停止
                        vgProp(obs,VGOBS_TETHERSTATE,VGOBS_SPIN);
                        vgObservPlyr(obs,e2c);
                        vgProp(obs,VGOBS_SPINRAD,120.0f);
                        vgProp(obs,VGOBS_SPINDELTA,0.3F);
                        vgProp(obs,VGOBS_SPINELEV,50.0f);
                        if(heliBspeed>0.0f)
                                heliBspeed-=0.0025f;
                        vgProp(h_blade1,VGFX_BSPEED,heliBspeed);
                        vgProp(h_blade2,VGFX_BSPEED,heliBspeed);
                        if(timeNow>30.0f)
                                state=16;
                        break;
                default:
                case 16://缺省状态,重新初始化
                        vgProp(e_airhit,VGFX_STATE,VG_OFF);
                        vgProp(e_engsmoke,VGFX_STATE,VG_OFF);
                        vgProp(e_engburn,VGFX_STATE,VG_OFF);
                        vgProp(e_flash,VGFX_STATE,VG_OFF);
                        vgProp(e_explode,VGFX_STATE,VG_OFF);
                        vgProp(e_debris,VGFX_STATE,VG_OFF);
                        vgProp(e_fire,VGFX_STATE,VG_OFF);
                        vgProp(e_smoke,VGFX_STATE,VG_OFF);
                        vgProp(h_blade1,VGFX_STATE,VG_OFF);
                        vgProp(h_blade2,VGFX_STATE,VG_OFF);
                        vgProp(m1_trail,VGFX_STATE,VG_OFF);
                        vgProp(m2_trail,VGFX_STATE,VG_OFF);
                        vgProp(m1_flame,VGFX_STATE,VG_OFF);
                        vgProp(m2_flame,VGFX_STATE,VG_OFF);
                        vgProp(t_flash,VGFX_STATE,VG_OFF);
                        vgProp(t_explode1,VGFX_STATE,VG_OFF);
                        vgProp(t_explode2,VGFX_STATE,VG_OFF);
                        vgProp(t_debris1,VGFX_STATE,VG_OFF);
                        vgProp(t_debris2,VGFX_STATE,VG_OFF);
                        vgProp(t_flame,VGFX_STATE,VG_OFF);
                        vgProp(t_fire,VGFX_STATE,VG_OFF);
                        vgProp(t_smoke,VGFX_STATE,VG_OFF);
                        vgProp(e_trail1,VGFX_STATE,VG_OFF);
                        vgProp(e_trail2,VGFX_STATE,VG_OFF);
                        vgProp(e_trail1,VGFX_FADEDUR,VGFX_ALWAYS);
                        vgProp(e_trail2,VGFX_FADEDUR,VGFX_ALWAYS);
                        vgProp(e_trail1,VGFX_DURATION,VGFX_ALWAYS);
                        vgProp(e_trail1,VGFX_DURATION,VGFX_ALWAYS);
                        vgAddPlyrIsect(tank,fortank);
                        //删除导弹一路径
                        m=(int)vgGetProp(missile1_nav,VGNAV_NUM_MARKERS);
                        n=(int)vgGetProp(missile1_path,VGPATH_NUM_CTRLPTS);
                        vgProp(missile1_nav,VGCOMMON_ENABLED,VG_OFF);
                        for(idx=m-1;idx>0;idx--)
                        {
                                vgNavigatorDeleteMarkerByIndex(missile1_nav,idx);
                        }
                        for(idx=n-1;idx>0;idx--)
                        {
                                vgPathDeleteCtrlPointByIndex(missile1_path,idx);
                        }
                        //删除导弹二路径
                        m=(int)vgGetProp(missile2_nav,VGNAV_NUM_MARKERS);
                        n=(int)vgGetProp(missile2_path,VGPATH_NUM_CTRLPTS);
                        vgProp(missile2_nav,VGCOMMON_ENABLED,VG_OFF);
                        for(idx=m-1;idx>0;idx--)
                        {
                                vgNavigatorDeleteMarkerByIndex(missile2_nav,idx);
                        }
                        for(idx=n-1;idx>0;idx--)
                        {
                                vgPathDeleteCtrlPointByIndex(missile2_path,idx);
                        }
                        //删除直升机救援路径
                        m=(int)vgGetProp(helitoe2c_nav,VGNAV_NUM_MARKERS);
                        n=(int)vgGetProp(helitoe2c_path,VGPATH_NUM_CTRLPTS);
                        vgProp(helitoe2c_nav,VGCOMMON_ENABLED,VG_OFF);
                        for(idx=m-1;idx>0;idx--)
                        {
                                vgNavigatorDeleteMarkerByIndex(helitoe2c_nav,idx);
                        }
                        for(idx=n-1;idx>0;idx--)
                        {
                                vgPathDeleteCtrlPointByIndex(helitoe2c_path,idx);
                        }
                        //初始化各种变量
                        z=ZSTART;
                        p=0.0f;
                        r=-25.0f;
                        e2c_radius=1000.0f;
                        m=n=i=0;
                        m1used=0;
                        m2used=0;
                        m1launchable=0;
                        m2launchable=0;
                        tankhitted=0;
                        e2ccrashed=0;
                        vgProp(tank_nav,VGCOMMON_ENABLED,VG_OFF);
                        vgProp(heli_nav,VGCOMMON_ENABLED,VG_OFF);
                        vgProp(tankupdown_nav,VGCOMMON_ENABLED,VG_OFF);
                        vgProp(tank,VGPLYR_SPLINE_NAVIGATOR,VG_OFF);
                        vgProp(heli,VGPLYR_SPLINE_NAVIGATOR,VG_OFF);
                        //重置角色对象
                        pos=vgNewPos();
                        vgAddSceneObj(scene,m1);
                        vgAddSceneObj(scene,m2);
                        vgProp(missile1,VGPLYR_CSREF,VGPLYR_PLYR);
                        vgPlyrPlyrRef(missile1,heli);
                        vgPosVec(pos,-1.75f,-1.0f,-0.683f,0,0,0);
                        vgPos(missile1,pos);
                        vgProp(missile2,VGPLYR_CSREF,VGPLYR_PLYR);
                        vgPlyrPlyrRef(missile2,heli);
                        vgPosVec(pos,1.75f,-1.0f,-0.683f,0,0,0);
                        vgPos(missile2,pos);
                        vgPosVec(pos,2944.0f,3215.0f,17.828f,-180,0,0);
                        vgPos(heli,pos);
                        vgPosVec(pos,2208.0f,1035.0f,0.0f,0,0,0);
                        vgPos(tank,pos);
                        vgPosVec(pos,0,0,0,0,0,0);
                        vgPos(tank_crater,pos);
                        vgPos(e2c_crater,pos);
                        vgDelPos(pos);

                        startTime=vgGetTime();
                        state=0;
                        break;
                }
                deltaFrameTime=vgGetDeltaFrameTime();
        }
        vgExit(0);
}

//计算角色对象在指定位置处的速度矢量
void computeVVec(float *vv,vgPosition *pos)
{
        float x,y,z,h,p,r;
        static float dx=0.0f,dy=0.0f,dz=0.0f;
        vgGetPosVec(pos,&x,&y,&z,&h,&p,&r);
        if(deltaFrameTime)
        {
                vv[0]=(dx-x)/deltaFrameTime;
                vv[1]=(dy-y)/deltaFrameTime;
                vv[2]=(dz-z)/deltaFrameTime;
        }
        else
        {
                vv[0]=vv[1]=vv[2]=0.0f;
        }
        dx=x;
        dy=y;
        dz=z;
}
//处理用户交互事件
void stateHandler(void)
{
        long i;
        static vgWindow *win=NULL;
        static vgMouse mouse;
        static int oldlb=0;
        static int oldrb=0;
        if(!win)
                win=vgGetWin(0);
        //按下鼠标左键发射第一枚导弹
        if(m1launchable)
        {
                vgGetMouse(&mouse);
                if(mouse.lb!=oldlb)
                {
                        state=6;
                        oldlb=mouse.lb;
                        m1launchable=0;
                }
        }
        //按下鼠标右键发射第二枚导弹
        if(m2launchable)
        {
                vgGetMouse(&mouse);
                if(mouse.rb!=oldrb)
                {
                        state=7;
                        oldrb=mouse.rb;
                        m2launchable=0;
                }
        }
        //处理键盘输入
        while(i=vgGetWinKey(win))
        {
                switch(i)
                {
                case ' ':
                        if(e2cDownable)
                                state=11;
                        else
                                state=16;
                        break;
                default:
                        break;
                }
        }
}
//通道回调函数
void DrawInfoCallBack(vgCommon *chan,void *udata)
{
        GLint matmode;
        GLfloat projmat[16];
        char str[256],showstate[80];

        switch(state)
        {
        case 0:
        case 1:
                strcpy(showstate,"welcome to the show!");
                break;
        case 2:
                strcpy(showstate,"the tank is moving!");
                break;
        case 3:
                strcpy(showstate,"the tank is locked!");
                break;
        case 4:
        case 5:
                strcpy(showstate,"the helicopter-action!");
                if(m1launchable && m2launchable)
                        strcpy(showstate,"you can fire now!");
                break;
        case 6:
        case 7:
                strcpy(showstate,"broken arrow!");
                break;
        case 8:
        case 9:
        case 10:
                strcpy(showstate,"The tank is cracked!");
                if(e2cDownable)
                        strcpy(showstate,"be care for the E2C!");
                break;
        case 11:
        case 12:
        case 13:
                strcpy(showstate,"the e2c is in trouble!");
                break;
        case 14:
                strcpy(showstate,"the helicopter is in trouble!");
                break;
        case 15:
        case 16:
                strcpy(showstate,"Game over");
                break;
        default:
                strcpy(showstate,"what is this?");
                break;
        }
       
        sprintf(str,"ElapsedTime:%7.2f StateTimer:%7.2f StateNow(%d):%s",vgGetTime(),timeNow,state,showstate);

        pfPushState();


        pfDisable(PFEN_TEXTURE);
        pfDisable(PFEN_FOG);
        pfDisable(PFEN_LIGHTING);
        pfTransparency(PFTR_FAST);
        glDisable(GL_DEPTH_TEST);

        glGetIntegerv(GL_MATRIX_MODE,&matmode);
        glMatrixMode(GL_PROJECTION);
        glGetFloatv(GL_PROJECTION_MATRIX,projmat);
        glMatrixMode(matmode);

        pfPushIdentMatrix();

        glGetIntegerv(GL_MATRIX_MODE,&matmode);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0,1024,0,768);
        glMatrixMode(matmode);
        glColor3ub(255,0,255);
        vgFontSize(15,20);
        vgFontPos(40,20,0);
        vgDrawFont(str);
        pfPopMatrix();

        glMatrixMode(GL_PROJECTION);
        glLoadMatrixf(projmat);
        glMatrixMode(matmode);
        glEnable(GL_DEPTH_TEST);

        pfPopState();
}

        //获取随机整数
        int randomNum(int number)
        {
                srand((unsigned)time(NULL));
                return(int)(number/(float)RAND_MAX*rand());
        }
fail.JPG

demo2.rar

228.53 KB, 下载次数: 18

begin 评论于2011-10-13 10:35:27
我的也是,不能,不过你还好点,我的编译都没过

手机版|VR开发网 ( 津ICP备18009691号 ) 统计 网安备12019202000257

GMT+8, 2020-9-20 06:30 PM

返回顶部