前言

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

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

在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项目源码