hge source explor 0xD graphics Ⅳ

外部接口

　　这里的接口提供给用户进行固定的步骤：BeginScene；自己的渲染；EndScene。

　　接下来从教程2的渲染顺序来看函数

 Gfx_BeginScene(HTARGET targ)

在渲染前的准备工作

  • TestCooperativeLevel 测试设备是否可用
  • 如果在窗口模式下要检测BackBufferFormat，并更新BPP
  • _GfxRestore 重设dx
  • 检测顶点缓存：如果顶点缓存为不为0，则还未调用EndScene
  • 在当前渲染对象并非参数中的渲染对象时：设置表面、渲染对象、设置渲染参数、设置投影矩阵、设置视图矩阵
  • 设置为当前渲染对象
  • IDirect3DDevice::BeginScene
  • 锁定顶点缓存：等待顶点

bool CALL HGE_Impl::Gfx_BeginScene(HTARGET targ)
{
    LPDIRECT3DSURFACE8 pSurf=0, pDepth=0;
    D3DDISPLAYMODE Mode;
    CRenderTargetList *target=(CRenderTargetList *)targ;

    HRESULT hr = pD3DDevice->TestCooperativeLevel();
    if (hr == D3DERR_DEVICELOST) return false;
    else if (hr == D3DERR_DEVICENOTRESET)
    {
        if(bWindowed)
        {
            if(FAILED(pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &Mode)) || Mode.Format==D3DFMT_UNKNOWN)
            {
                _PostError("Can‘t determine desktop video mode");
                return false;
            }

            d3dppW.BackBufferFormat = Mode.Format;
            if(_format_id(Mode.Format) < 4) nScreenBPP=16;
            else nScreenBPP=32;
        }

        if(!_GfxRestore()) return false;
    }

    if(VertArray)
    {
        _PostError("Gfx_BeginScene: Scene is already being rendered");
        return false;
    }

    if(target != pCurTarget)
    {
        if(target)
        {
            target->pTex->GetSurfaceLevel(0, &pSurf);
            pDepth=target->pDepth;
        }
        else
        {
            pSurf=pScreenSurf;
            pDepth=pScreenDepth;
        }
        if(FAILED(pD3DDevice->SetRenderTarget(pSurf, pDepth)))
        {
            if(target) pSurf->Release();
            _PostError("Gfx_BeginScene: Can‘t set render target");
            return false;
        }
        if(target)
        {
            pSurf->Release();
            if(target->pDepth) pD3DDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE );
            else pD3DDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE );
            _SetProjectionMatrix(target->width, target->height);
        }
        else
        {
            if(bZBuffer) pD3DDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE );
            else pD3DDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE );
            _SetProjectionMatrix(nScreenWidth, nScreenHeight);
        }

        pD3DDevice->SetTransform(D3DTS_PROJECTION, &matProj);
        D3DXMatrixIdentity(&matView);
        pD3DDevice->SetTransform(D3DTS_VIEW, &matView);

        pCurTarget=target;
    }

    pD3DDevice->BeginScene();
    pVB->Lock( 0, 0, (BYTE**)&VertArray, 0 );

    return true;
}

Gfx_BeginScene

 Gfx_Clear(DWORD color)

清理背景的工作

  • 清理背景为指定的颜色

void CALL HGE_Impl::Gfx_Clear(DWORD color)
{
    if(pCurTarget)
    {
        if(pCurTarget->pDepth)
            pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, color, 1.0f, 0 );
        else
            pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET, color, 1.0f, 0 );
    }
    else
    {
        if(bZBuffer)
            pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, color, 1.0f, 0 );
        else
            pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET, color, 1.0f, 0 );
    }
}

Gfx_Clear

 Gfx_RenderQuad(const hgeQuad *quad)

渲染矩形的准备工作

  • 判断是否锁定顶点缓冲区
  • 当前的渲染图元类型是否为矩阵 || 顶点是否超过 || 当前的纹理是否相同 || 渲染模式是否相同 : 只要一项不同，就先渲染当前的所有顶点，在渲染完后设置元数=0
  • 将矩形的顶点导入顶点缓存
  • 图元数增长

void CALL HGE_Impl::Gfx_RenderQuad(const hgeQuad *quad)
{
    if(VertArray)
    {
        if(CurPrimType!=HGEPRIM_QUADS || nPrim>=VERTEX_BUFFER_SIZE/HGEPRIM_QUADS || CurTexture!=quad->tex || CurBlendMode!=quad->blend)
        {
            _render_batch();

            CurPrimType=HGEPRIM_QUADS;
            if(CurBlendMode != quad->blend) _SetBlendMode(quad->blend);
            if(quad->tex != CurTexture)
            {
                pD3DDevice->SetTexture( 0, (LPDIRECT3DTEXTURE8)quad->tex );
                CurTexture = quad->tex;
            }
        }

        memcpy(&VertArray[nPrim*HGEPRIM_QUADS], quad->v, sizeof(hgeVertex)*HGEPRIM_QUADS);
        nPrim++;
    }
}

Gfx_RenderQuad

 Gfx_RenderTriple(const hgeTriple *triple)

渲染三角形的准备工作

  • 类似矩形

void CALL HGE_Impl::Gfx_RenderTriple(const hgeTriple *triple)
{
    if(VertArray)
    {
        if(CurPrimType!=HGEPRIM_TRIPLES || nPrim>=VERTEX_BUFFER_SIZE/HGEPRIM_TRIPLES || CurTexture!=triple->tex || CurBlendMode!=triple->blend)
        {
            _render_batch();

            CurPrimType=HGEPRIM_TRIPLES;
            if(CurBlendMode != triple->blend) _SetBlendMode(triple->blend);
            if(triple->tex != CurTexture) {
                pD3DDevice->SetTexture( 0, (LPDIRECT3DTEXTURE8)triple->tex );
                CurTexture = triple->tex;
            }
        }

        memcpy(&VertArray[nPrim*HGEPRIM_TRIPLES], triple->v, sizeof(hgeVertex)*HGEPRIM_TRIPLES);
        nPrim++;
    }
}

Gfx_RenderTriple

 Gfx_RenderLine(float x1, float y1, float x2, float y2, DWORD color, float z)

渲染直线的准备工作

  • 判断是否锁定顶点缓冲区
  • 当前的渲染图元类型是否为矩阵 || 顶点是否超过 || 当前的纹理是否相同 || 渲染模式是否相同 : 只要一项不同，就先渲染当前的所有顶点，在渲染完后设置元数=0
  • 直线顶点导入顶点缓存
  • 图元数增长

void CALL HGE_Impl::Gfx_RenderLine(float x1, float y1, float x2, float y2, DWORD color, float z)
{
    if(VertArray)
    {
        if(CurPrimType!=HGEPRIM_LINES || nPrim>=VERTEX_BUFFER_SIZE/HGEPRIM_LINES || CurTexture || CurBlendMode!=BLEND_DEFAULT)
        {
            _render_batch();

            CurPrimType=HGEPRIM_LINES;
            if(CurBlendMode != BLEND_DEFAULT) _SetBlendMode(BLEND_DEFAULT);
            if(CurTexture) { pD3DDevice->SetTexture(0, 0); CurTexture=0; }
        }

        int i=nPrim*HGEPRIM_LINES;
        VertArray[i].x = x1; VertArray[i+1].x = x2;
        VertArray[i].y = y1; VertArray[i+1].y = y2;
        VertArray[i].z     = VertArray[i+1].z = z;
        VertArray[i].col   = VertArray[i+1].col = color;
        VertArray[i].tx    = VertArray[i+1].tx =
        VertArray[i].ty    = VertArray[i+1].ty = 0.0f;

        nPrim++;
    }
}

Gfx_RenderLine

 Gfx_EndScene()

渲染工作结束

  • 对顶点缓存中的所有顶点进行渲染；设置参数为true，在渲染结束之后顶点缓存vertarry=0
  • IDirect3DDevice::EndScene
  • IDirect3DDevice::Present 清理

void CALL HGE_Impl::Gfx_EndScene()
{
    _render_batch(true);
    pD3DDevice->EndScene();
    if(!pCurTarget) pD3DDevice->Present( NULL, NULL, NULL, NULL );
}

Gfx_EndScene

 Gfx_StartBatch(int prim_type, HTEXTURE tex, int blend, int *max_prim)

在批量渲染前的工作

  • 获取顶点缓冲，并将原来的顶点渲染
  • 设置当前的渲染图元、当前渲染混合模式、当前纹理
  • 得到最大能渲染的个数
  • 返回顶点缓存地址：准备载入顶点

hgeVertex* CALL HGE_Impl::Gfx_StartBatch(int prim_type, HTEXTURE tex, int blend, int *max_prim)
{
    if(VertArray)
    {
        _render_batch();

        CurPrimType=prim_type;
        if(CurBlendMode != blend) _SetBlendMode(blend);
        if(tex != CurTexture)
        {
            pD3DDevice->SetTexture( 0, (LPDIRECT3DTEXTURE8)tex );
            CurTexture = tex;
        }

        *max_prim=VERTEX_BUFFER_SIZE / prim_type;
        return VertArray;
    }
    else return 0;
}

Gfx_StartBatch

 Gfx_FinishBatch(int nprim)

批量渲染前准备工作结束

  • 设置需要渲染的图元的个数

void CALL HGE_Impl::Gfx_FinishBatch(int nprim)
{
    nPrim=nprim;
}

Gfx_FinishBatch

 Gfx_SetClipping(int x, int y, int w, int h)

设置裁剪

  • 设置一个视口，并且设置视口的长、宽
  • 然后将现有的顶点缓冲中的顶点渲染
  • 设置视口
  • 重新设置投影矩阵

void CALL HGE_Impl::Gfx_SetClipping(int x, int y, int w, int h)
{
    D3DVIEWPORT8 vp;
    int scr_width, scr_height;

    if(!pCurTarget) {
        scr_width=pHGE->System_GetStateInt(HGE_SCREENWIDTH);
        scr_height=pHGE->System_GetStateInt(HGE_SCREENHEIGHT);
    }
    else {
        scr_width=Texture_GetWidth((HTEXTURE)pCurTarget->pTex);
        scr_height=Texture_GetHeight((HTEXTURE)pCurTarget->pTex);
    }

    if(!w) {
        vp.X=0;
        vp.Y=0;
        vp.Width=scr_width;
        vp.Height=scr_height;
    }
    else
    {
        if(x<0) { w+=x; x=0; }
        if(y<0) { h+=y; y=0; }

        if(x+w > scr_width) w=scr_width-x;
        if(y+h > scr_height) h=scr_height-y;

        vp.X=x;
        vp.Y=y;
        vp.Width=w;
        vp.Height=h;
    }

    vp.MinZ=0.0f;
    vp.MaxZ=1.0f;

    _render_batch();
    pD3DDevice->SetViewport(&vp);

    D3DXMATRIX tmp;
    D3DXMatrixScaling(&matProj, 1.0f, -1.0f, 1.0f);
    D3DXMatrixTranslation(&tmp, -0.5f, +0.5f, 0.0f);
    D3DXMatrixMultiply(&matProj, &matProj, &tmp);
    D3DXMatrixOrthoOffCenterLH(&tmp, (float)vp.X, (float)(vp.X+vp.Width), -((float)(vp.Y+vp.Height)), -((float)vp.Y), vp.MinZ, vp.MaxZ);
    D3DXMatrixMultiply(&matProj, &matProj, &tmp);
    pD3DDevice->SetTransform(D3DTS_PROJECTION, &matProj);
}

Gfx_SetClipping

 Gfx_SetTransform(float x, float y, float dx, float dy, float rot, float hscale, float vscale)

设置移动变换

  • 通过参数对视图矩阵进行变换
  • 渲染顶点缓冲中的所有顶点
  • 重设投影矩阵

void CALL HGE_Impl::Gfx_SetTransform(float x, float y, float dx, float dy, float rot, float hscale, float vscale)
{
    D3DXMATRIX tmp;

    if(vscale==0.0f) D3DXMatrixIdentity(&matView);
    else
    {
        D3DXMatrixTranslation(&matView, -x, -y, 0.0f);
        D3DXMatrixScaling(&tmp, hscale, vscale, 1.0f);
        D3DXMatrixMultiply(&matView, &matView, &tmp);
        D3DXMatrixRotationZ(&tmp, -rot);
        D3DXMatrixMultiply(&matView, &matView, &tmp);
        D3DXMatrixTranslation(&tmp, x+dx, y+dy, 0.0f);
        D3DXMatrixMultiply(&matView, &matView, &tmp);
    }

    _render_batch();
    pD3DDevice->SetTransform(D3DTS_VIEW, &matView);
}

Gfx_SetTransform


图形模块 结束了！

时间： 2024-10-29 20:01:38

hge source explor 0xD graphics Ⅳ的相关文章

hge source explor 0xC graphics Ⅲ

这里关于图形模块的内部接口部分 内部调用接口 内部接口主要完成:关于固定流水线的设置:dx的初始化:dx的结束 可以说内部接口已经完成了左右工作,只要进行组合调用即可 _GfxInit() DX的初始化函数 Direct3DCreate8 创建接口 GetAdapterIdentifier 获得设备信息,在这里可以查询设备能够做到什么 PRESENT_PARAMETER 参数的填写 CreateDevice 创建设备 _AdjustWindow 这个函数原来在window模块里已经考虑过,在这里

hge source explor 0xA graphics Ⅰ

Graphics 在这一部分完成初始化DX,并且完成固定流水线,然后在进行渲染. 在这一部分会用到的数据结构和参数有: 参数: D3DPRESENT_PARAMETERS* d3dpp; D3DPRESENT_PARAMETERS d3dppW; D3DPRESENT_PARAMETERS d3dppFS; IDirect3D8* pD3D; IDirect3DDevice8* pD3DDevice; IDirect3DVertexBuffer8* pVB; IDirect3DIndexBuff

hge source explor 0xB graphics Ⅱ

整个graphics.cpp文件可以分成4个部分:内部接口:纹理相关:渲染对象相关:DX初始化等. Texture & Target 关于纹理的部分: CTextureList struct CTextureList { HTEXTURE tex; int width; int height; CTextureList* next; };   Texture_Create(int width, int height) 创建纹理 D3DXCreateTexture创建一个纹理 HTEXTURE C

hge source explor 0x5 input module

Input Module 前面提到输入事件,那么对输入事件分类,分类如下 /* ** HGE Input Event type constants */ #define INPUT_KEYDOWN 1 #define INPUT_KEYUP 2 #define INPUT_MBUTTONDOWN 3 #define INPUT_MBUTTONUP 4 #define INPUT_MOUSEMOVE 5 #define INPUT_MOUSEWHEEL 6 接下来看每个函数 _InputInit

hge source explor 0x3 windows module

Windows窗口 在这里继续看窗口相关的函数,前面看到的部分能够生成一个窗口.在hge的代码中,我们可以看到别的函数处理窗口相关的事情,当然不是指的消息处理函数. 在hge中消息处理函数是最主要的函数之一,完成了整个游戏的信息输入. 另外的和窗口相关的函数是 graphics.cpp void HGE_Impl::_AdjustWindow() void HGE_Impl::_Resize(int width, int height) 从函数的名字中可以看到都是处理窗口的变化的函数   实现

hge source explor 0x8 timer

Timer 时间部分,在hge中提供对于fps的控制,时间的控制等. 其中会用到的参数有. hge_impl.h // Timer float fTime; float fDeltaTime; DWORD nFixedDelta; int nFPS; DWORD t0, t0fps, dt; int cfps; 在system.cpp中使用到,用来控制帧率 if(dt >= nFixedDelta) { // fDeltaTime = time step in seconds returned

hge source explor 0x4 input module

Input Module hge中的输入并没有用到Direct Input,在window消息构造输入信息. 对于鼠标和键盘,输入信息用一个结构来处理,hge中的信息事件的结构 /* ** HGE Input Event structure */ struct hgeInputEvent { int type; // event type int key; // key code int flags; // event flags int chr; // character code int w

HGE source explor 0x0

本文准备开始HGE游戏引擎的代码阅读,其实我已经阅读完HGE的代码了,这里将准备再重新阅读代码.阅读代码将准备将代码拆开阅读,按每种功能分开来阅读,分别准备如下: 游戏的窗口 对于任意一个程序来说,一个窗口都是必须的,所以游戏的最基本的也是一个窗口.那么我们找到HGE关于游戏窗口的部分,详细了解这部分.(窗口君:我是一切的基础哦.) 游戏的输入信息 对于一个游戏来说,互动也是必须的,既然要互动那玩家的输入必不可少.在这里我们可以看到HGE关于输入的部分,创建输入的事件然后,当然是等处理.(输入君

hge source explor 0x9 Power &amp; Random &amp; Ini

Power 电源管理部分,会用到的参数为: // Power int nPowerStatus; HMODULE hKrnl32; GetSystemPowerStatusFunc lpfnGetSystemPowerStatus; _InitPowerStatus() 初始化电源信息: LoadLibrary("kernel32.dll") 获得函数GetSystemPowerStatus地址 调用_UpdatePowerStatus void HGE_Impl::_InitPowe