DirectX11 With Windows SDK--13 动手实现一个简易Effects框架、阴影效果绘制

前言

到现在为止，所有的教程项目都没有使用effects11框架类来管理资源。因为在d3dcompile api (#47)版本中，如果你尝试编译fx_5_0的效果文件，会收到这样的警告：
x4717: effects deprecated for d3dcompiler_47

在未来的版本中，d3dcompiler可能会停止对fx11的支持，所以我们需要自行去管理各种特效，并改用hlsl编译器去编译每一个着色器。同时，在阅读本章之前，你需要先学习本系列前面的一些重点章节再继续：

主题	版次	创建时间	修改时间
01 directx11初始化	第5版	2018/5/12	2018/8/18
02 顶点/像素着色器的创建、顶点缓冲区	第10版	2018/5/13	2018/8/30
03 索引缓冲区、常量缓冲区	第7版	2018/5/13	2018/8/20
09 纹理映射与采样器状态	第7版	2018/7/12	2018/8/11
11 混合状态与光栅化状态	第3版	2018/7/21	2018/8/8
12 深度/模板状态、反射绘制	第5版	2018/7/28	2018/9/16

在directxtk中的effects.h可以看到它实现了一系列effects管理类，相比effects11框架库，它缺少了反射机制，并且使用的是它内部已经写好、编译好的着色器。directxtk的effects也只不过是为了简化游戏开发流程而设计出来的。当然，里面的一部分源码实现也值得我们去学习。

注意：这章经历了一次十分大的改动，原先所使用的basicfx类因为在后续的章节中发现很难扩展，所以进行了一次大幅度重构。并会逐渐替换掉后面教程的项目源码所使用的basicfx。

在这一章的学习过后，你将会理解effects11的一部分运作机制是怎样的。而关于它的反射机制、着色器编译部分不会进行探讨。

这篇教程还会提到用深度/模板状态去实现简单的阴影效果，但不会深入数学公式原理。

directx11 with windows sdk完整目录

github项目源码

回顾renderstates类

目前的renderstates类存放有比较常用的各种状态，原来在effects11框架下是可以在fx文件初始化各种渲染状态，并设置到technique11中。但现在我们只能在c++代码层中一次性创建好各种所需的渲染状态：

class renderstates
{
public:
    template <class t>
    using comptr = microsoft::wrl::comptr<t>;

    static bool isinit();

    static void initall(comptr<id3d11device> device);
    // 使用comptr无需手工释放

public:
    static comptr<id3d11rasterizerstate> rswireframe;       // 光栅化器状态：线框模式
    static comptr<id3d11rasterizerstate> rsnocull;          // 光栅化器状态：无背面裁剪模式
    static comptr<id3d11rasterizerstate> rscullclockwise;   // 光栅化器状态：顺时针裁剪模式

    static comptr<id3d11samplerstate> sslinearwrap;         // 采样器状态：线性过滤
    static comptr<id3d11samplerstate> ssanistropicwrap;     // 采样器状态：各项异性过滤

    static comptr<id3d11blendstate> bsnocolorwrite;     // 混合状态：不写入颜色
    static comptr<id3d11blendstate> bstransparent;      // 混合状态：透明混合
    static comptr<id3d11blendstate> bsalphatocoverage;  // 混合状态：alpha-to-coverage

    static comptr<id3d11depthstencilstate> dsswritestencil;     // 深度/模板状态：写入模板值
    static comptr<id3d11depthstencilstate> dssdrawwithstencil;  // 深度/模板状态：对指定模板值的区域进行绘制
    static comptr<id3d11depthstencilstate> dssnodoubleblend;    // 深度/模板状态：无二次混合区域
    static comptr<id3d11depthstencilstate> dssnodepthtest;      // 深度/模板状态：关闭深度测试
    static comptr<id3d11depthstencilstate> dssnodepthwrite;     // 深度/模板状态：仅深度测试，不写入深度值
};

具体的设置可以参照源码或者上一章内容。

简易effects框架

该effects框架支持的功能如下：

1. 管理/修改常量缓冲区的内容，并进行应用(apply)
2. 编译hlsl着色器而不是fx文件
3. 管理/使用四种渲染状态
4. 切换渲染模式(涉及到渲染管线各种资源的绑定、切换)
5. 仅更新修改的变量所对应的常量缓冲区块

不过它也有这样的缺陷：

1. 一个特效类对应一套着色器和所使用的常量缓冲区，所属着色器代码的变动很可能会引起对框架类的修改，因为缺乏反射机制而导致灵活性差。

文件结构

首先是文件结构：

其中能够暴露给程序使用的只有头文件effects.h，里面可以存放多套不同的特效框架类的声明，而关于每个框架类的实现部分都应当用一个独立的源文件存放。而effecthelper.h则是用来帮助管理常量缓冲区的，服务于各种框架类的实现部分以及所属的源文件，因此不应该直接使用。

理论上它也是可以做成静态库使用的，然后着色器代码稳定后也不应当变动。在使用的时候只需要包含头文件effects.h即可。

effecthelper.h

该头文件包含了一些有用的东西，但它需要在包含特效类实现的源文件中使用，且必须晚于effects.h包含。

在堆上进行类的内存对齐

有些类型需要在堆上按16字节对齐，比如xmvector和xmmatrix，虽然说拿这些对象作为类的成员不太合适，毕竟分配在堆上的话基本上无法保证内存按16字节对齐了，但还是希望能够做到。在vs的corecrt_malloc.h(只要有包含stdlib.h, malloc.h之一的头文件都可以)中有这样的一个函数：_aligned_malloc，它可以指定需要分配的内存字节大小以及按多少字节对齐。其中对齐值必须为2的整数次幂的字节数。

void * _aligned_malloc(  
    size_t size,        // [in]分配内存字节数
    size_t alignment    // [in]按多少字节内存来对齐
);  

若一个类中包含有已经指定内存对齐的成员，则需要优先把这些成员放到最前。

然后与之对应的就是_aligned_free函数了，它可以释放之前由_aligned_malloc分配得到的内存。

下面是类模板alignedtype的实现，让需要内存对齐的类去继承该类即可。它重载了operator new和operator delete的实现：

// 若类需要内存对齐，从该类派生
template<class derivedtype>
struct alignedtype
{
    static void* operator new(size_t size)
    {
        const size_t alignedsize = __alignof(derivedtype);

        static_assert(alignedsize > 8, "alignednew is only useful for types with > 8 byte alignment! did you forget a __declspec(align) on derivedtype?");

        void* ptr = _aligned_malloc(size, alignedsize);

        if (!ptr)
            throw std::bad_alloc();

        return ptr;
    }

    static void operator delete(void * ptr)
    {
        _aligned_free(ptr);
    }
};

需要注意的是，继承alignedtype的类或者其成员必须本身有__declspec(align)的标识。若是内部成员，在所有包含该标识的值中最大的align值 必须是2的整数次幂且必须大于8。

下面演示了正确的和错误的行为：

// 错误！vertexposcolor按4字节对齐！
struct vertexposcolor : alignedtype<vertexpos>
{
    xmfloat3 pos;
    xmfloat4 color;
};

// 正确！data按16字节对齐，因为pos本身是按16字节对齐的。
struct data : alignedtype<vertexpos>
{
    xmvector pos;
    int val;
};

// 正确！vector类按16字节对齐
__declspec(align(16))
struct vector : alignedtype<vector>
{
    float x;
    float y;
    float z;
    float w;
};

这里alignedtype<t>主要是用于basicobjectfx::impl类，因为其内部包含了xmvector和xmmatrix类型的成员，且该类需要分配在堆上。

常量缓冲区管理

一个常量缓冲区可能会被创建、更新或者绑定到管线。若常量缓冲区的值没有发生变化，我们不希望它进行无意义的更新。我们可以使用一个dirty标记，确认它是否被修改过。常量缓冲区的任一内部成员发生修改的话，我们就将数据更新到常量缓冲区并恢复该标记。

首先是抽象基类cbufferbase：

struct cbufferbase
{
    template<class t>
    using comptr = microsoft::wrl::comptr<t>;

    bool isdirty;
    comptr<id3d11buffer> cbuffer;

    virtual void createbuffer(comptr<id3d11device> device) = 0;
    virtual void updatebuffer(comptr<id3d11devicecontext> devicecontext) = 0;
    virtual void bindvs(comptr<id3d11devicecontext> devicecontext) = 0;
    virtual void bindhs(comptr<id3d11devicecontext> devicecontext) = 0;
    virtual void bindds(comptr<id3d11devicecontext> devicecontext) = 0;
    virtual void bindgs(comptr<id3d11devicecontext> devicecontext) = 0;
    virtual void bindcs(comptr<id3d11devicecontext> devicecontext) = 0;
    virtual void bindps(comptr<id3d11devicecontext> devicecontext) = 0;
};

这么做是为了方便我们放入数组进行遍历。

然后是派生类cbufferobject，startslot指定了hlsl对应cbuffer的索引，t则是c++对应的结构体，存储临时数据：

template<uint startslot, class t>
struct cbufferobject : cbufferbase
{
    t data;

    void createbuffer(comptr<id3d11device> device) override
    {
        if (cbuffer != nullptr)
            return;
        d3d11_buffer_desc cbd;
        zeromemory(&cbd, sizeof(cbd));
        cbd.usage = d3d11_usage_default;
        cbd.bindflags = d3d11_bind_constant_buffer;
        cbd.cpuaccessflags = 0;
        cbd.bytewidth = sizeof(t);
        hr(device->createbuffer(&cbd, nullptr, cbuffer.getaddressof()));
    }

    void updatebuffer(comptr<id3d11devicecontext> devicecontext) override
    {
        if (isdirty)
        {
            isdirty = false;
            devicecontext->updatesubresource(cbuffer.get(), 0, nullptr, &data, 0, 0);
        }
    }

    void bindvs(comptr<id3d11devicecontext> devicecontext) override
    {
        devicecontext->vssetconstantbuffers(startslot, 1, cbuffer.getaddressof());
    }

    void bindhs(comptr<id3d11devicecontext> devicecontext) override
    {
        devicecontext->hssetconstantbuffers(startslot, 1, cbuffer.getaddressof());
    }

    void bindds(comptr<id3d11devicecontext> devicecontext) override
    {
        devicecontext->dssetconstantbuffers(startslot, 1, cbuffer.getaddressof());
    }

    void bindgs(comptr<id3d11devicecontext> devicecontext) override
    {
        devicecontext->gssetconstantbuffers(startslot, 1, cbuffer.getaddressof());
    }

    void bindcs(comptr<id3d11devicecontext> devicecontext) override
    {
        devicecontext->cssetconstantbuffers(startslot, 1, cbuffer.getaddressof());
    }

    void bindps(comptr<id3d11devicecontext> devicecontext) override
    {
        devicecontext->pssetconstantbuffers(startslot, 1, cbuffer.getaddressof());
    }
};

关于常量缓冲区临时变量的修改则在后续的内容。

basicobjectfx类--管理对象绘制的资源

首先是抽象基类ieffects，它仅允许被移动，并且仅包含apply方法。

class ieffect
{
public:
    // 使用模板别名(c++11)简化类型名
    template <class t>
    using comptr = microsoft::wrl::comptr<t>;

    ieffect() = default;

    // 不支持复制构造
    ieffect(const ieffect&) = delete;
    ieffect& operator=(const ieffect&) = delete;

    // 允许转移
    ieffect(ieffect&& movefrom) = default;
    ieffect& operator=(ieffect&& movefrom) = default;

    virtual ~ieffect() = default;

    // 更新并绑定常量缓冲区
    virtual void apply(comptr<id3d11devicecontext> devicecontext) = 0;
};

原来的id3dx11effectpass包含的方法apply用于在各个着色器阶段绑定所需要的常量缓冲区、纹理等资源，并更新之前有所修改的常量缓冲区。现在我们实现effects框架中的apply方法也是这么做的。

然后是派生类basicobjectfx，从它的方法来看，包含了单例获取、渲染状态的切换、修改常量缓冲区某一成员的值、应用变更四个大块：

class basicobjectfx : public ieffect
{
public:
    // 使用模板别名(c++11)简化类型名
    template <class t>
    using comptr = microsoft::wrl::comptr<t>;

    basicobjectfx();
    virtual ~basicobjectfx() override;

    basicobjectfx(basicobjectfx&& movefrom);
    basicobjectfx& operator=(basicobjectfx&& movefrom);

    // 获取单例
    static basicobjectfx& get();

    

    // 初始化basix.fx所需资源并初始化渲染状态
    bool initall(comptr<id3d11device> device);


    //
    // 渲染模式的变更
    //

    // 默认状态来绘制
    void setrenderdefault(comptr<id3d11devicecontext> devicecontext);
    // alpha混合绘制
    void setrenderalphablend(comptr<id3d11devicecontext> devicecontext);
    // 无二次混合
    void setrendernodoubleblend(comptr<id3d11devicecontext> devicecontext, uint stencilref);
    // 仅写入模板值
    void setwritestencilonly(comptr<id3d11devicecontext> devicecontext, uint stencilref);
    // 对指定模板值的区域进行绘制，采用默认状态
    void setrenderdefaultwithstencil(comptr<id3d11devicecontext> devicecontext, uint stencilref);
    // 对指定模板值的区域进行绘制，采用alpha混合
    void setrenderalphablendwithstencil(comptr<id3d11devicecontext> devicecontext, uint stencilref);
    // 2d默认状态绘制
    void set2drenderdefault(comptr<id3d11devicecontext> devicecontext);
    // 2d混合绘制
    void set2drenderalphablend(comptr<id3d11devicecontext> devicecontext);

    

    //
    // 矩阵设置
    //

    void xm_callconv setworldmatrix(directx::fxmmatrix w);
    void xm_callconv setviewmatrix(directx::fxmmatrix v);
    void xm_callconv setprojmatrix(directx::fxmmatrix p);
    void xm_callconv setworldviewprojmatrix(directx::fxmmatrix w, directx::cxmmatrix v, directx::cxmmatrix p);

    void xm_callconv settextransformmatrix(directx::fxmmatrix w);

    void xm_callconv setreflectionmatrix(directx::fxmmatrix r);
    void xm_callconv setshadowmatrix(directx::fxmmatrix s);
    void xm_callconv setrefshadowmatrix(directx::fxmmatrix refs);
    
    //
    // 光照、材质和纹理相关设置
    //

    // 各种类型灯光允许的最大数目
    static const int maxlights = 5;

    void setdirlight(size_t pos, const directionallight& dirlight);
    void setpointlight(size_t pos, const pointlight& pointlight);
    void setspotlight(size_t pos, const spotlight& spotlight);

    void setmaterial(const material& material);

    void settexture(comptr<id3d11shaderresourceview> texture);

    void xm_callconv seteyepos(directx::fxmvector eyepos);



    //
    // 状态开关设置
    //

    void setreflectionstate(bool ison);
    void setshadowstate(bool ison);
    

    // 应用常量缓冲区和纹理资源的变更
    void apply(comptr<id3d11devicecontext> devicecontext);
    
private:
    class impl;
    std::unique_ptr<impl> pimpl;
};

xm_callconv即在第六章之前提到的__vectorcall或__fastcall约定。

然后来到basicobjectfx.cpp，首先包含了对应hlsl五个cbuffer的c++结构体：

#include "effects.h"
#include "effecthelper.h"
#include "vertex.h"
#include <d3dcompiler.h>
#include <experimental/filesystem>
using namespace directx;
using namespace std::experimental;

//
// 这些结构体对应hlsl的结构体，仅供该文件使用。需要按16字节对齐
//

struct cbchangeseverydrawing
{
    directx::xmmatrix world;
    directx::xmmatrix worldinvtranspose;
    directx::xmmatrix textransform;
    material material;
};

struct cbdrawingstates
{
    int isreflection;
    int isshadow;
    directx::xmint2 pad;
};

struct cbchangeseveryframe
{
    directx::xmmatrix view;
    directx::xmvector eyepos;
};

struct cbchangesonresize
{
    directx::xmmatrix proj;
};


struct cbchangesrarely
{
    directx::xmmatrix reflection;
    directx::xmmatrix shadow;
    directx::xmmatrix refshadow;
    directionallight dirlight[basicobjectfx::maxlights];
    pointlight pointlight[basicobjectfx::maxlights];
    spotlight spotlight[basicobjectfx::maxlights];
};

effecthelper.h需要放在effects.h之后。

这5个结构体都放在源文件是因为这些结构体仅限于在该文件种使用。

basicobjectfx::impl类

之前在basicobjectfx中声明了impl类，主要目的是为了将类的成员和方法定义都转移到源文件中。不仅可以减少basicobjectfx类的压力，还可以避免暴露上面的五个结构体。

basicobjectfx::impl类包含一切所需资源，以及一个编译着色器的方法：

//
// basicobjectfx::impl 需要先于basicobjectfx的定义
//

class basicobjectfx::impl : public alignedtype<basicobjectfx::impl>
{
public:
    // 必须显式指定
    impl() = default;
    ~impl() = default;

    // objfilenameinout为编译好的着色器二进制文件(.*so)，若有指定则优先寻找该文件并读取
    // hlslfilename为着色器代码，若未找到着色器二进制文件则编译着色器代码
    // 编译成功后，若指定了objfilenameinout，则保存编译好的着色器二进制信息到该文件
    // ppblobout输出着色器二进制信息
    hresult createshaderfromfile(const wchar* objfilenameinout, const wchar* hlslfilename, lpcstr entrypoint, lpcstr shadermodel, id3dblob** ppblobout);

public:
    // 需要16字节对齐的优先放在前面
    cbufferobject<0, cbchangeseverydrawing> cbdrawing;      // 每次对象绘制的常量缓冲区
    cbufferobject<1, cbdrawingstates>       cbstates;       // 每次绘制状态变更的常量缓冲区
    cbufferobject<2, cbchangeseveryframe>   cbframe;        // 每帧绘制的常量缓冲区
    cbufferobject<3, cbchangesonresize>     cbonresize;     // 每次窗口大小变更的常量缓冲区
    cbufferobject<4, cbchangesrarely>       cbrarely;       // 几乎不会变更的常量缓冲区
    bool isdirty;                                           // 是否有值变更
    std::vector<cbufferbase*> cbufferptrs;                  // 统一管理下面所有的常量缓冲区


    comptr<id3d11vertexshader> vertexshader3d;              // 用于3d的顶点着色器
    comptr<id3d11pixelshader>  pixelshader3d;               // 用于3d的像素着色器
    comptr<id3d11vertexshader> vertexshader2d;              // 用于2d的顶点着色器
    comptr<id3d11pixelshader>  pixelshader2d;               // 用于2d的像素着色器

    comptr<id3d11inputlayout>  vertexlayout2d;              // 用于2d的顶点输入布局
    comptr<id3d11inputlayout>  vertexlayout3d;              // 用于3d的顶点输入布局

    comptr<id3d11shaderresourceview> texture;               // 用于绘制的纹理

};

着色器的编译方法这里不再赘述。

构造/析构/单例

这里用一个匿名空间保管单例对象的指针。当有一个实例被构造出来的时候就会给其赋值。后续就不允许再被实例化了，可以使用get方法获取该单例。

namespace
{
    // basicobjectfx单例
    static basicobjectfx * pinstance = nullptr;
}

basicobjectfx::basicobjectfx()
{
    if (pinstance)
        throw std::exception("basicobjectfx is a singleton!");
    pinstance = this;
    pimpl = std::make_unique<basicobjectfx::impl>();
}

basicobjectfx::~basicobjectfx()
{
}

basicobjectfx::basicobjectfx(basicobjectfx && movefrom)
{
    pimpl.swap(movefrom.pimpl);
}

basicobjectfx & basicobjectfx::operator=(basicobjectfx && movefrom)
{
    pimpl.swap(movefrom.pimpl);
    return *this;
}

basicobjectfx & basicobjectfx::get()
{
    if (!pinstance)
        throw std::exception("basicobjectfx needs an instance!");
    return *pinstance;
}

basicobjectfx::initall方法

basicobjectfx::initall方法负责创建出所有的着色器和常量缓冲区，以及所有的渲染状态：

bool basicobjectfx::initall(comptr<id3d11device> device)
{
    if (!device)
        return false;

    comptr<id3dblob> blob;

    // 创建顶点着色器(2d)
    hr(pimpl->createshaderfromfile(l"hlsl\\basicobject_vs_2d.vso", l"hlsl\\basicobject_vs_2d.hlsl", "vs", "vs_5_0", blob.getaddressof()));
    hr(device->createvertexshader(blob->getbufferpointer(), blob->getbuffersize(), nullptr, pimpl->vertexshader2d.getaddressof()));
    // 创建顶点布局(2d)
    hr(device->createinputlayout(vertexposnormaltex::inputlayout, arraysize(vertexposnormaltex::inputlayout),
        blob->getbufferpointer(), blob->getbuffersize(), pimpl->vertexlayout2d.getaddressof()));

    // 创建像素着色器(2d)
    hr(pimpl->createshaderfromfile(l"hlsl\\basicobject_ps_2d.pso", l"hlsl\\basicobject_ps_2d.hlsl", "ps", "ps_5_0", blob.releaseandgetaddressof()));
    hr(device->createpixelshader(blob->getbufferpointer(), blob->getbuffersize(), nullptr, pimpl->pixelshader2d.getaddressof()));

    // 创建顶点着色器(3d)
    hr(pimpl->createshaderfromfile(l"hlsl\\basicobject_vs_3d.vso", l"hlsl\\basicobject_vs_3d.hlsl", "vs", "vs_5_0", blob.releaseandgetaddressof()));
    hr(device->createvertexshader(blob->getbufferpointer(), blob->getbuffersize(), nullptr, pimpl->vertexshader3d.getaddressof()));
    // 创建顶点布局(3d)
    hr(device->createinputlayout(vertexposnormaltex::inputlayout, arraysize(vertexposnormaltex::inputlayout),
        blob->getbufferpointer(), blob->getbuffersize(), pimpl->vertexlayout3d.getaddressof()));

    // 创建像素着色器(3d)
    hr(pimpl->createshaderfromfile(l"hlsl\\basicobject_ps_3d.pso", l"hlsl\\basicobject_ps_3d.hlsl", "ps", "ps_5_0", blob.releaseandgetaddressof()));
    hr(device->createpixelshader(blob->getbufferpointer(), blob->getbuffersize(), nullptr, pimpl->pixelshader3d.getaddressof()));


    // 初始化
    renderstates::initall(device);

    pimpl->cbufferptrs.assign({
        &pimpl->cbdrawing, 
        &pimpl->cbframe, 
        &pimpl->cbstates, 
        &pimpl->cbonresize, 
        &pimpl->cbrarely});

    // 创建常量缓冲区
    for (auto& pbuffer : pimpl->cbufferptrs)
    {
        pbuffer->createbuffer(device);
    }

    return true;
}

各种渲染状态的切换

下面所有的渲染模式使用的是线性wrap采样器。

basicfx::setrenderdefault方法--默认渲染

basicobjectfx::setrenderdefault方法使用了默认的3d像素着色器和顶点着色器，并且其余各状态都保留使用默认状态：

void basicobjectfx::setrenderdefault()
{
    md3dimmediatecontext->iasetinputlayout(mvertexlayout3d.get());
    md3dimmediatecontext->vssetshader(mvertexshader3d.get(), nullptr, 0);
    md3dimmediatecontext->rssetstate(nullptr);
    md3dimmediatecontext->pssetshader(mpixelshader3d.get(), nullptr, 0);
    md3dimmediatecontext->pssetsamplers(0, 1, renderstates::sslinearwrap.getaddressof());
    md3dimmediatecontext->omsetdepthstencilstate(nullptr, 0);
    md3dimmediatecontext->omsetblendstate(nullptr, nullptr, 0xffffffff);
}

basicobjectfx::setrenderalphablend方法--alpha透明混合渲染

该绘制模式关闭了光栅化裁剪，并采用透明混合方式。

void basicobjectfx::setrenderalphablend()
{
    md3dimmediatecontext->iasetinputlayout(mvertexlayout3d.get());
    md3dimmediatecontext->vssetshader(mvertexshader3d.get(), nullptr, 0);
    md3dimmediatecontext->rssetstate(renderstates::rsnocull.get());
    md3dimmediatecontext->pssetshader(mpixelshader3d.get(), nullptr, 0);
    md3dimmediatecontext->pssetsamplers(0, 1, renderstates::sslinearwrap.getaddressof());
    md3dimmediatecontext->omsetdepthstencilstate(nullptr, 0);
    md3dimmediatecontext->omsetblendstate(renderstates::bstransparent.get(), nullptr, 0xffffffff);
}

basicobjectfx::setrendernodoubleblend方法--无重复混合(单次混合)

该绘制模式用于绘制阴影，防止过度混合。需要指定绘制区域的模板值。

void basicobjectfx::setrendernodoubleblend(uint stencilref)
{
    md3dimmediatecontext->iasetinputlayout(mvertexlayout3d.get());
    md3dimmediatecontext->vssetshader(mvertexshader3d.get(), nullptr, 0);
    md3dimmediatecontext->rssetstate(renderstates::rsnocull.get());
    md3dimmediatecontext->pssetshader(mpixelshader3d.get(), nullptr, 0);
    md3dimmediatecontext->pssetsamplers(0, 1, renderstates::sslinearwrap.getaddressof());
    md3dimmediatecontext->omsetdepthstencilstate(renderstates::dssnodoubleblend.get(), stencilref);
    md3dimmediatecontext->omsetblendstate(renderstates::bstransparent.get(), nullptr, 0xffffffff);
}

basicobjectfx::setwritestencilonly方法--仅写入模板值

该模式用于向模板缓冲区写入用户指定的模板值，并且不写入到深度缓冲区和后备缓冲区。

void basicobjectfx::setwritestencilonly(uint stencilref)
{
    md3dimmediatecontext->iasetinputlayout(mvertexlayout3d.get());
    md3dimmediatecontext->vssetshader(mvertexshader3d.get(), nullptr, 0);
    md3dimmediatecontext->rssetstate(nullptr);
    md3dimmediatecontext->pssetshader(mpixelshader3d.get(), nullptr, 0);
    md3dimmediatecontext->pssetsamplers(0, 1, renderstates::sslinearwrap.getaddressof());
    md3dimmediatecontext->omsetdepthstencilstate(renderstates::dsswritestencil.get(), stencilref);
    md3dimmediatecontext->omsetblendstate(renderstates::bsnocolorwrite.get(), nullptr, 0xffffffff);
}

basicobjectfx::setrenderdefaultwithstencil方法--对指定模板值区域进行常规绘制

该模式下，仅对模板缓冲区的模板值和用户指定的相等的区域进行常规绘制。

void basicobjectfx::setrenderdefaultwithstencil(uint stencilref)
{
    md3dimmediatecontext->iasetinputlayout(mvertexlayout3d.get());
    md3dimmediatecontext->vssetshader(mvertexshader3d.get(), nullptr, 0);
    md3dimmediatecontext->rssetstate(renderstates::rscullclockwise.get());
    md3dimmediatecontext->pssetshader(mpixelshader3d.get(), nullptr, 0);
    md3dimmediatecontext->pssetsamplers(0, 1, renderstates::sslinearwrap.getaddressof());
    md3dimmediatecontext->omsetdepthstencilstate(renderstates::dssdrawwithstencil.get(), stencilref);
    md3dimmediatecontext->omsetblendstate(nullptr, nullptr, 0xffffffff);
}

basicobjectfx::setrenderalphablendwithstencil方法--对指定模板值区域进行alpha透明混合绘制

该模式下，仅对模板缓冲区的模板值和用户指定的相等的区域进行alpha透明混合绘制。

void basicobjectfx::setrenderalphablendwithstencil(uint stencilref)
{
    md3dimmediatecontext->iasetinputlayout(mvertexlayout3d.get());
    md3dimmediatecontext->vssetshader(mvertexshader3d.get(), nullptr, 0);
    md3dimmediatecontext->rssetstate(renderstates::rsnocull.get());
    md3dimmediatecontext->pssetshader(mpixelshader3d.get(), nullptr, 0);
    md3dimmediatecontext->pssetsamplers(0, 1, renderstates::sslinearwrap.getaddressof());
    md3dimmediatecontext->omsetdepthstencilstate(renderstates::dssdrawwithstencil.get(), stencilref);
    md3dimmediatecontext->omsetblendstate(renderstates::bstransparent.get(), nullptr, 0xffffffff);
}

basicobjectfx::set2drenderdefault方法--2d默认绘制

该模式使用的是2d顶点着色器和像素着色器，并修改为2d输入布局。

void basicobjectfx::set2drenderdefault()
{
    md3dimmediatecontext->iasetinputlayout(mvertexlayout2d.get());
    md3dimmediatecontext->vssetshader(mvertexshader2d.get(), nullptr, 0);
    md3dimmediatecontext->rssetstate(nullptr);
    md3dimmediatecontext->pssetshader(mpixelshader2d.get(), nullptr, 0);
    md3dimmediatecontext->pssetsamplers(0, 1, renderstates::sslinearwrap.getaddressof());
    md3dimmediatecontext->omsetdepthstencilstate(nullptr, 0);
    md3dimmediatecontext->omsetblendstate(nullptr, nullptr, 0xffffffff);
}

basicobjectfx::set2drenderalphablend方法--2d透明混合绘制

相比上面，多了透明混合状态。

void basicobjectfx::set2drenderalphablend()
{
    md3dimmediatecontext->iasetinputlayout(mvertexlayout2d.get());
    md3dimmediatecontext->vssetshader(mvertexshader2d.get(), nullptr, 0);
    md3dimmediatecontext->rssetstate(renderstates::rsnocull.get());
    md3dimmediatecontext->pssetshader(mpixelshader2d.get(), nullptr, 0);
    md3dimmediatecontext->pssetsamplers(0, 1, renderstates::sslinearwrap.getaddressof());
    md3dimmediatecontext->omsetdepthstencilstate(nullptr, 0);
    md3dimmediatecontext->omsetblendstate(renderstates::bstransparent.get(), nullptr, 0xffffffff);
}

更新常量缓冲区

下面这些所有的方法会更新cbufferobject中的临时数据，数据脏标记被设为true：

void xm_callconv basicobjectfx::setworldmatrix(directx::fxmmatrix w)
{
    auto& cbuffer = pimpl->cbdrawing;
    cbuffer.data.world = w;
    cbuffer.data.worldinvtranspose = xmmatrixtranspose(xmmatrixinverse(nullptr, w));
    pimpl->isdirty = cbuffer.isdirty = true;
}

void xm_callconv basicobjectfx::setviewmatrix(fxmmatrix v)
{
    auto& cbuffer = pimpl->cbframe;
    cbuffer.data.view = v;
    pimpl->isdirty = cbuffer.isdirty = true;
}

void xm_callconv basicobjectfx::setprojmatrix(fxmmatrix p)
{
    auto& cbuffer = pimpl->cbonresize;
    cbuffer.data.proj = p;
    pimpl->isdirty = cbuffer.isdirty = true;
}

void xm_callconv basicobjectfx::setworldviewprojmatrix(fxmmatrix w, cxmmatrix v, cxmmatrix p)
{
    pimpl->cbdrawing.data.world = w;
    pimpl->cbdrawing.data.worldinvtranspose = xmmatrixtranspose(xmmatrixinverse(nullptr, w));
    pimpl->cbframe.data.view = v;
    pimpl->cbonresize.data.proj = p;

    auto& pcbuffers = pimpl->cbufferptrs;
    pcbuffers[0]->isdirty = pcbuffers[1]->isdirty = pcbuffers[3]->isdirty = true;
    pimpl->isdirty = true;
}

void xm_callconv basicobjectfx::settextransformmatrix(fxmmatrix w)
{
    auto& cbuffer = pimpl->cbdrawing;
    cbuffer.data.textransform = w;
    pimpl->isdirty = cbuffer.isdirty = true;
}

void xm_callconv basicobjectfx::setreflectionmatrix(fxmmatrix r)
{
    auto& cbuffer = pimpl->cbrarely;
    cbuffer.data.reflection = r;
    pimpl->isdirty = cbuffer.isdirty = true;
}

void xm_callconv basicobjectfx::setshadowmatrix(fxmmatrix s)
{
    auto& cbuffer = pimpl->cbrarely;
    cbuffer.data.shadow = s;
    pimpl->isdirty = cbuffer.isdirty = true;
}

void xm_callconv basicobjectfx::setrefshadowmatrix(directx::fxmmatrix refs)
{
    auto& cbuffer = pimpl->cbrarely;
    cbuffer.data.refshadow = refs;
    pimpl->isdirty = cbuffer.isdirty = true;
}

void basicobjectfx::setdirlight(size_t pos, const directionallight & dirlight)
{
    auto& cbuffer = pimpl->cbrarely;
    cbuffer.data.dirlight[pos] = dirlight;
    pimpl->isdirty = cbuffer.isdirty = true;
}

void basicobjectfx::setpointlight(size_t pos, const pointlight & pointlight)
{
    auto& cbuffer = pimpl->cbrarely;
    cbuffer.data.pointlight[pos] = pointlight;
    pimpl->isdirty = cbuffer.isdirty = true;
}

void basicobjectfx::setspotlight(size_t pos, const spotlight & spotlight)
{
    auto& cbuffer = pimpl->cbrarely;
    cbuffer.data.spotlight[pos] = spotlight;
    pimpl->isdirty = cbuffer.isdirty = true;
}

void basicobjectfx::setmaterial(const material & material)
{
    auto& cbuffer = pimpl->cbdrawing;
    cbuffer.data.material = material;
    pimpl->isdirty = cbuffer.isdirty = true;
}

void basicobjectfx::settexture(comptr<id3d11shaderresourceview> texture)
{
    pimpl->texture = texture;
}

void xm_callconv basicobjectfx::seteyepos(fxmvector eyepos)
{
    auto& cbuffer = pimpl->cbframe;
    cbuffer.data.eyepos = eyepos;
    pimpl->isdirty = cbuffer.isdirty = true;
}

void basicobjectfx::setreflectionstate(bool ison)
{
    auto& cbuffer = pimpl->cbstates;
    cbuffer.data.isreflection = ison;
    pimpl->isdirty = cbuffer.isdirty = true;
}

void basicobjectfx::setshadowstate(bool ison)
{
    auto& cbuffer = pimpl->cbstates;
    cbuffer.data.isshadow = ison;
    pimpl->isdirty = cbuffer.isdirty = true;
}

basicobjectfx::apply方法--应用缓冲区、纹理资源并进行更新

basicobjectfx::apply首先将所需要用到的缓冲区绑定到渲染管线上，并设置纹理，然后才是视情况更新常量缓冲区。

下面的缓冲区数组索引值同时也对应了之前编译期指定的startslot值。

首先检验总的脏标记是否为true，若有任意数据被修改，则检验每个常量缓冲区的脏标记，并根据该标记决定是否要更新常量缓冲区。

void basicobjectfx::apply(comptr<id3d11devicecontext> devicecontext)
{
    auto& pcbuffers = pimpl->cbufferptrs;
    // 将缓冲区绑定到渲染管线上
    pcbuffers[0]->bindvs(devicecontext);
    pcbuffers[1]->bindvs(devicecontext);
    pcbuffers[2]->bindvs(devicecontext);
    pcbuffers[3]->bindvs(devicecontext);
    pcbuffers[4]->bindvs(devicecontext);

    pcbuffers[0]->bindps(devicecontext);
    pcbuffers[1]->bindps(devicecontext);
    pcbuffers[2]->bindps(devicecontext);
    pcbuffers[4]->bindps(devicecontext);

    // 设置纹理
    devicecontext->pssetshaderresources(0, 1, pimpl->texture.getaddressof());

    if (pimpl->isdirty)
    {
        pimpl->isdirty = false;
        for (auto& pcbuffer : pcbuffers)
        {
            pcbuffer->updatebuffer(devicecontext);
        }
    }
}

当然，目前basicfx能做的事情还是比较有限的，并且还需要随着hlsl代码的变动而随之调整。更多的功能会在后续教程中实现。

绘制平面阴影

使用xmmatrixshadow可以生成阴影矩阵，根据光照类型和位置对几何体投影到平面上的。

xmmatrix xmmatrixshadow(
    fxmvector shadowplane,      // 平面向量(nx, ny, nz, d)
    fxmvector lightposition);   // w = 0时表示平行光方向， w = 1时表示光源位置

通常指定的平面会稍微比实际平面高那么一点点，以避免深度缓冲区资源争夺导致阴影显示有问题。

使用模板缓冲区防止过度混合

一个物体投影到平面上时，投影区域的某些位置可能位于多个三角形之内，这会导致这些位置会有多个像素通过测试并进行混合操作，渲染的次数越多，显示的颜色会越黑。

我们可以使用模板缓冲区来解决这个问题。

1. 在之前的例子中，我们用模板值为0的区域表示非镜面反射区，模板值为1的区域表示为镜面反射区；
2. 使用renderstates::dssnodoubleblend的深度模板状态，当给定的模板值和深度/模板缓冲区的模板值一致时，通过模板测试并对模板值加1，绘制该像素的混合，然后下一次由于给定的模板值比深度/模板缓冲区的模板值小1，不会再通过模板测试，也就阻挡了后续像素的绘制；
3. 应当先绘制镜面的阴影区域，再绘制正常的阴影区域。

着色器代码的变化

basic_ps_2d.hlsl文件变化如下：

#include "basic.fx"

// 像素着色器(2d)
float4 ps_2d(vertex2dout pin) : sv_target
{
    float4 color = tex.sample(sam, pin.tex);
    clip(color.a - 0.1f);
    return color;
}

basic_ps_3d.hlsl文件变化如下：

#include "basic.fx"

// 像素着色器(3d)
float4 ps_3d(vertex3dout pin) : sv_target
{
    // 提前进行裁剪，对不符合要求的像素可以避免后续运算
    float4 texcolor = tex.sample(sam, pin.tex);
    clip(texcolor.a - 0.1f);

    // 标准化法向量
    pin.normalw = normalize(pin.normalw);

    // 顶点指向眼睛的向量
    float3 toeyew = normalize(geyeposw - pin.posw);

    // 初始化为0 
    float4 ambient = float4(0.0f, 0.0f, 0.0f, 0.0f);
    float4 diffuse = float4(0.0f, 0.0f, 0.0f, 0.0f);
    float4 spec = float4(0.0f, 0.0f, 0.0f, 0.0f);
    float4 a = float4(0.0f, 0.0f, 0.0f, 0.0f);
    float4 d = float4(0.0f, 0.0f, 0.0f, 0.0f);
    float4 s = float4(0.0f, 0.0f, 0.0f, 0.0f);
    int i;


    // 强制展开循环以减少指令数
    [unroll]
    for (i = 0; i < gnumdirlight; ++i)
    {
        computedirectionallight(gmaterial, gdirlight[i], pin.normalw, toeyew, a, d, s);
        ambient += a;
        diffuse += d;
        spec += s;
    }
    
    [unroll]
    for (i = 0; i < gnumpointlight; ++i)
    {
        pointlight pointlight = gpointlight[i];
        // 若当前在绘制反射物体，需要对光照进行反射矩阵变换
        [flatten]
        if (gisreflection)
        {
            pointlight.position = (float3) mul(float4(pointlight.position, 1.0f), greflection);
        }

        computepointlight(gmaterial, pointlight, pin.posw, pin.normalw, toeyew, a, d, s);
        ambient += a;
        diffuse += d;
        spec += s;
    }
    
    [unroll]
    for (i = 0; i < gnumspotlight; ++i)
    {
        spotlight spotlight = gspotlight[i];
        // 若当前在绘制反射物体，需要对光照进行反射矩阵变换
        [flatten]
        if (gisreflection)
        {
            spotlight.position = (float3) mul(float4(spotlight.position, 1.0f), greflection);
        }

        computespotlight(gmaterial, spotlight, pin.posw, pin.normalw, toeyew, a, d, s);
        ambient += a;
        diffuse += d;
        spec += s;
    }
    

    
    float4 litcolor = texcolor * (ambient + diffuse) + spec;
    litcolor.a = texcolor.a * gmaterial.diffuse.a;
    return litcolor;
}

basic_vs_2d.hlsl变化如下：

#include "basic.fx"

// 顶点着色器(2d)
vertex2dout vs_2d(vertex2din pin)
{
    vertex2dout pout;
    pout.posh = float4(pin.pos, 1.0f);
    pout.tex = mul(float4(pin.tex, 0.0f, 1.0f), gtextransform).xy;
    return pout;
}

basic_vs_3d.hlsl变化如下：

#include "basic.fx"

// 顶点着色器(3d)
vertex3dout vs_3d(vertex3din pin)
{
    vertex3dout pout;
    
    float4 posw = mul(float4(pin.posl, 1.0f), gworld);
    // 若当前在绘制反射物体，先进行反射操作
    [flatten]
    if (gisreflection)
    {
        posw = mul(posw, greflection);
    }
    // 若当前在绘制阴影，先进行投影操作
    [flatten]
    if (gisshadow)
    {
        posw = (gisreflection ? mul(posw, grefshadow) : mul(posw, gshadow));
    }

    pout.posh = mul(mul(posw, gview), gproj);
    pout.posw = mul(float4(pin.pos, 1.0f), gworld).xyz;
    pout.normalw = mul(pin.normall, (float3x3) gworldinvtranspose);
    pout.tex = mul(float4(pin.tex, 0.0f, 1.0f), gtextransform).xy;
    return pout;
}

gameobject类与basicobjectfx类的对接

由于gameobject类也承担了绘制方法，那么最后的apply也需要交给游戏对象来调用。因此gameobject::draw方法变更如下：

void gameobject::draw(comptr<id3d11devicecontext> devicecontext, basicobjectfx& effect)
{
    // 设置顶点/索引缓冲区
    uint strides = sizeof(vertexposnormaltex);
    uint offsets = 0;
    devicecontext->iasetvertexbuffers(0, 1, mvertexbuffer.getaddressof(), &strides, &offsets);
    devicecontext->iasetindexbuffer(mindexbuffer.get(), dxgi_format_r16_uint, 0);

    // 更新数据并应用
    effect.setworldmatrix(xmloadfloat4x4(&mworldmatrix));
    effect.settextransformmatrix(xmloadfloat4x4(&mtextransform));
    effect.settexture(mtexture);
    effect.setmaterial(mmaterial);
    effect.apply(devicecontext);

    devicecontext->drawindexed(mindexcount, 0, 0);
}

场景绘制

现在场景只有墙体、地板、木箱和镜面。

第1步: 镜面区域写入模板缓冲区

// *********************
// 1. 给镜面反射区域写入值1到模板缓冲区
// 

mbasicobjectfx.setwritestencilonly(md3dimmediatecontext, 1);
mmirror.draw(md3dimmediatecontext, mbasicobjectfx);

第2步: 绘制不透明的反射物体

// ***********************
// 2. 绘制不透明的反射物体
//

// 开启反射绘制
mbasicobjectfx.setreflectionstate(true);
mbasicobjectfx.setrenderdefaultwithstencil(md3dimmediatecontext, 1);

mwalls[2].draw(md3dimmediatecontext, mbasicobjectfx);
mwalls[3].draw(md3dimmediatecontext, mbasicobjectfx);
mwalls[4].draw(md3dimmediatecontext, mbasicobjectfx);
mfloor.draw(md3dimmediatecontext, mbasicobjectfx);
mwoodcrate.draw(md3dimmediatecontext, mbasicobjectfx);

第3步: 绘制不透明反射物体的阴影

// ***********************
// 3. 绘制不透明反射物体的阴影
//

mwoodcrate.setmaterial(mshadowmat);
mbasicobjectfx.setshadowstate(true);    // 反射开启，阴影开启            
mbasicobjectfx.setrendernodoubleblend(md3dimmediatecontext, 1);

mwoodcrate.draw(md3dimmediatecontext, mbasicobjectfx);

// 恢复到原来的状态
mbasicobjectfx.setshadowstate(false);
mwoodcrate.setmaterial(mwoodcratemat);

第4步: 绘制透明镜面

// ***********************
// 4. 绘制透明镜面
//

// 关闭反射绘制
mbasicobjectfx.setreflectionstate(false);
mbasicobjectfx.setrenderalphablendwithstencil(md3dimmediatecontext, 1);

mmirror.draw(md3dimmediatecontext, mbasicobjectfx);

第5步：绘制不透明的正常物体

// ************************
// 5. 绘制不透明的正常物体
//
mbasicobjectfx.setrenderdefault(md3dimmediatecontext);

for (auto& wall : mwalls)
    wall.draw(md3dimmediatecontext, mbasicobjectfx);
mfloor.draw(md3dimmediatecontext, mbasicobjectfx);
mwoodcrate.draw(md3dimmediatecontext, mbasicobjectfx);

第6步：绘制不透明正常物体的阴影

// ************************
// 6. 绘制不透明正常物体的阴影
//
mwoodcrate.setmaterial(mshadowmat);
mbasicobjectfx.setshadowstate(true);    // 反射关闭，阴影开启
mbasicobjectfx.setrendernodoubleblend(md3dimmediatecontext, 0);

mwoodcrate.draw(md3dimmediatecontext, mbasicobjectfx);

mbasicobjectfx.setshadowstate(false);       // 阴影关闭
mwoodcrate.setmaterial(mwoodcratemat);

最终绘制效果如下：

注意该样例只生成点光灯到地板的阴影。你可以用各种摄像机模式来进行测试。

2018/9/18：该教程后面16, 17, 19章还没有及时更换为新的框架，需要一段时间进行替换。并且篇幅庞大难免有遗漏错误之处，望谅解。

directx11 with windows sdk完整目录

github项目源码