|  | 
 
 发表于 2015-6-10 09:38:40
|
显示全部楼层 
| 所有代码都在这了,,,这大概是我的算法吧,,,比较low。复制代码#include "mdl.h"
#include "mdl_Sprite.h"
#include "windows.h"
#include "cmath"
#include "ctime"
#include <VECTOR>
#include <iostream>
#include <functional>
mdl_sprite* gs;
struct spritedes
{
        spritedes::spritedes(DWORD SH)
        {
                sprite_handle = SH;
        }
        BOOL rS = 1;
        XMFLOAT2 position;
        float rotation=0;
        
        DWORD sprite_handle;
        
};
class globalttime
{
public:
        globalttime::globalttime()
        {
                startTime = clock();
                lastTime = startTime;
                currentTime = lastTime;
        }
        void update()
        {
                lastTime = currentTime;
                currentTime = clock();
                interval = currentTime - lastTime;
        }
        long getInter()
        {
                return interval;
        }
        long getCurrent()
        {
                return currentTime;
        }
        long getPassed()
        {
                return currentTime - startTime;
        }
private:
        clock_t startTime;
        clock_t lastTime;
        clock_t currentTime;
        long interval;
}*gt;
class msprite
{
public:
        msprite::msprite(){};
        msprite::msprite(char* filename)
        {
                teH = gs->load_texture(filename);
                spH = gs->init_sprite(teH);
                big = gs->spritemap[spH].big;
                
        }
        virtual void update()
        {
                
        }
        virtual void draw()
        {
                std::list < spritedes >::iterator iter = list.begin();
                for (unsigned int i = 0; i < list.size(); i++, iter++)
                {
                        int j = gs->RenList.size();
                        gs->add2RenList(spH);
                        gs->RenList[j].position = iter->position;
                        gs->RenList[j].rotation = iter->rotation;
                }
        }
protected:
        XMFLOAT2 big;
        DWORD teH;
        DWORD spH;
        std::list < spritedes >  list;
};
struct __polar
{
        float r = 0;
        float ra = 0;
        float rv = 0;
        float o = 0;
        float oa = 0;
        float ov = 0;
};
struct __rect
{
        XMFLOAT2 pos = { 0, 0 };
        XMFLOAT2 v = { 0, 0 };
};
class __coord
{
public:
        __coord::__coord(XMFLOAT2 __centre, std::function<void(__coord* lp)> __proc)
        {
                isRect = 0;
                centre = __centre;
                position = { 0, 0 };
                proc = __proc;
        }
        XMFLOAT2* getCentre()
        {
                return ¢re;
        }
        __polar* getLppolar()
        {
                return &polar;
        }
        __rect* getLprect()
        {
                return &rectC;
        }
        XMFLOAT2 getPos()
        {
                return position;
        }
        float getO()
        {
                return polar.o;
        }
        void changeCoordMode()
        {
        
        }
        void update()
        {
                proc(this);
                polar.ov += polar.oa * gt->getInter()/1000.0f;
                polar.o += polar.ov* gt->getInter() / 1000.0f;
                polar.rv += polar.ra* gt->getInter() / 1000.0f;
                polar.r += polar.rv* gt->getInter() / 1000.0f;
                while (polar.o >= XM_2PI)
                {
                        polar.o -= XM_2PI;
                }
                while (polar.o <= -XM_2PI)
                {
                        polar.o += XM_2PI;
                }
                position = { centre.x + polar.r * cosf(polar.o), centre.y + polar.r * sinf(polar.o) };
        }
private:
        bool isRect;
        XMFLOAT2 centre;
        XMFLOAT2 position;
        __polar polar;
        __rect rectC;
        std::function<void(__coord* lp)> proc;
};
class danmu:public msprite
{
public:
        danmu::danmu(char* filename)
        {
                teH = gs->load_texture(filename);
                spH = gs->init_sprite(teH);
                big = gs->spritemap[spH].big;
        }
        danmu::~danmu()
        {
                std::list<__coord*>::iterator iter = danmuLst.begin();
                for (unsigned int i = 0; i < danmuLst.size(); i++, iter++)
                {
                        delete *iter;
                }
                danmuLst.~list();
        }
        void initADanmu(__polar _polar,  std::function<void(__coord* lp)> __proc, XMFLOAT2 __centre = XMFLOAT2(w_width / 2.0f, w_height / 2.0f))
        {
                __coord* lpCoord = new __coord(__centre, __proc);
                __polar* lpPolar = lpCoord->getLppolar();
                memcpy(lpPolar, &_polar, sizeof(__polar));
                danmuLst.push_back(lpCoord);
        }
        void update()
        {
                std::list<__coord*>::iterator iter = danmuLst.begin();
                for (unsigned int i = 0; i < danmuLst.size(); i++, iter++)
                {
                        (*iter)->update();
                }
        }
        void draw()
        {
                std::list<__coord*>::iterator iter = danmuLst.begin();
                for (unsigned int i = 0; i < danmuLst.size(); i++, iter++)
                {
                        int j = gs->RenList.size();
                        gs->add2RenList(spH);
                        gs->RenList[j].position = (*iter)->getPos();
                        gs->RenList[j].rotation = (*iter)->getO() - XM_2PI / 4.0f;
                }
        
        }
        DWORD size()
        {
                return danmuLst.size();
        }
private:
        std::list<__coord*> danmuLst;
};
std::vector<msprite*> spriteLst;
#define installdProc __polar* polar = lp->getLppolar();\
__rect* rectC = lp->getLprect();\
XMFLOAT2* centre = lp->getCentre();\
float time = gt->getInter();
void dProc(__coord* lp)
{
        installdProc;
        if (polar->rv < 0)
        {
                polar->ra = 0;
                polar->rv = 0;
        }
}
int Render(int state, WORD reflect)
{
        static BOOL inited = FALSE;
        static danmu*id;
        if (!inited)
        {
                gs = new mdl_sprite;
                gt = new globalttime;
                id = new danmu("DT\\bullet.png");
                spriteLst.push_back(id);
                inited = true;
        }
        gt->update();
        static long timeProc = 0;
        if (gt->getPassed() -  timeProc >=300)
        {
        timeProc = gt->getPassed();
        const float d = 6.0;
        for (float i = 0; i < d; i++)
        {
                float o = XM_2PI / d*i;
                __polar p;
                p.o = o - XM_2PI / d /2.0f;
                p.ov = XM_2PI / 360.0 * 30;
                p.rv = 250.0;
                p.ra = -100;
                id->initADanmu(p, dProc);
                p.o = o ;
                p.ov = XM_2PI / 360.0 * 45;
                id->initADanmu(p, dProc);
        }
        }
        for (int i = 0; i < spriteLst.size(); i++)
        {
                spriteLst[i]->update();
                spriteLst[i]->draw();
        }
        char danmuNum[16] = { 0 };
        sprintf_s(danmuNum,"%u", id->size());
        SetWindowTextA(g_hWnd, danmuNum);
        gs->spriteRender();
        MDL_RenderPresent();
        gs->RenList.clear();
        MDL_clear();
        
        return state;
}
本意是实现一个发射器函数,一个弹幕处理函数,,但是还只封装了一个,坐标现在也只能处理极坐标。
 | 
 |