谈谈Hybird3D中的光栅化优化

看到空明流转分享了他的SALVIA 0.5.2优化谈，我也来说说Hybird3D中和光栅化相关的一些优化技术。

Hybird3D的设计目标是打造一款准实时的软件高质量渲染器，采用了光栅化和光线跟踪混合算法，光栅化用于渲染eye ray，光线跟踪则用于阴影、反射、折射、全局光等次级光线的计算。由于渲染器是以准实时(一帧渲染时间在几十毫秒到几秒之间)为设计目标的，因此性能优化是非常重要的，但同时为了能够实现高质量的软件渲染，在渲染器的架构和支持的特性上也不会因为性能而缩水和妥协。

光栅化算法

Hybird3D的光栅化算法主要采用的是Michael Abrash写的rasterization on Larrabee这篇paper，这个算法是目前我所知道的同时能够支持多线程和SIMD的最佳算法，这个算法保证了每个tile的光栅化可以由每个线程独立计算，而没有任何数据冲突，从而实现完全的无锁化计算。Larrabee有512bit的SIMD宽度，也就是一次可以计算16个float，在一般的支持SSE的CPU上我们只能使用128bit的SIMD指令一次计算4个float，虽然宽度少了，但不影响算法的应用。

Hybird3D也是采用的16x16的tile，光栅化的主要任务是计算某个像素上对应的三角图元和三角形重心坐标(另外为了后续的mipmap纹理插值我们还需要保存重心坐标的差分值)，有了图元和重心坐标就可以送到后端的LightShader和PixelShader中做进一步的计算了。一个像素上不一定只存在一个图元，半透明物体及其anti-alise等都会使得一个像素上存在多个图元，可以将这些图元保存为一个单向链表，同时为每个图元设置一个alpha值做为混合权重就可以了。

内存优化技巧

内存的优化主要包括内存的分配和cache的合理利用。在光栅化过程中会产生很多的临时对象，对象的数量不可预估但是每种对象的生命周期可以很容易的知道，所以我们可以采取多次分配一次释放的策略来实现非常高效的对象分配，根据不同的生命周期需要多个内存分配器，同时为了防止多线程冲突，每个线程需要独立的内存分配器。对cache的利用则需要合理的设计我们的渲染流水线以及合理的组织数据结构SoA(struct的array化)，让数据访问尽可能的集中。SoA不但可以让数据访问变得集中而且对SIMD指令非常友好，不过SoA的编程难度很高，会让代码变得非常难写和难读，

SIMD编程技巧

SIMD的编程一直是件脏活和累活，15年前我就开始使用MMX指令来加速应用，那个时候只能内嵌汇编，而且指令与普通的运算指令差别很大，写完之后过段时间自己也看不懂了，代码的维护是一个非常让人头疼的问题。后来出了intrinsics指令，可以在C代码中用函数的形式来编写SIMD指令，免去了手工写汇编的痛苦，但是intrinsics指令同普通的C运算符差别还是很大，代码的可读性依然不佳，好在SSE指令集还是比较规整的，大部分运算指令可以用C++运算符重载来包装intrinsics指令，下面给出我的包装函数供大家参考。

inline __m128 operator + (__m128 v1, __m128 v2)
{
    return _mm_add_ps(v1, v2);
}

inline __m128 operator - (__m128 v1, __m128 v2)
{
    return _mm_sub_ps(v1, v2);
}

inline __m128 operator * (__m128 v1, __m128 v2)
{
    return _mm_mul_ps(v1, v2);
}

inline __m128 operator / (__m128 v1, __m128 v2)
{
    return _mm_div_ps(v1, v2);
}

inline __m128 operator == (__m128 v1, __m128 v2)
{
    return _mm_cmpeq_ps(v1, v2);
}

inline __m128 operator != (__m128 v1, __m128 v2)
{
    return _mm_cmpneq_ps(v1, v2);
}

inline __m128 operator > (__m128 v1, __m128 v2)
{
    return _mm_cmpgt_ps(v1, v2);
}

inline __m128 operator >= (__m128 v1, __m128 v2)
{
    return _mm_cmpge_ps(v1, v2);
}

inline __m128 operator < (__m128 v1, __m128 v2)
{
    return _mm_cmplt_ps(v1, v2);
}

inline __m128 operator <= (__m128 v1, __m128 v2)
{
    return _mm_cmple_ps(v1, v2);
}

inline __m128 operator & (__m128 v1, __m128 v2)
{
    return _mm_and_ps(v1, v2);
}

inline __m128 operator | (__m128 v1, __m128 v2)
{
    return _mm_or_ps(v1, v2);
}

inline int MoveMask(__m128 v)
{
    return _mm_movemask_ps(v);
}

inline __m128 Max(__m128 v1, __m128 v2)
{
    return _mm_max_ps(v1, v2);
}

inline __m128 Min(__m128 v1, __m128 v2)
{
    return _mm_min_ps(v1, v2);
}

//mask ? a : b
inline __m128 Select(__m128 mask, __m128 a, __m128 b)
{
    return _mm_or_ps(_mm_and_ps(a, mask), _mm_andnot_ps(mask, b));
}

inline __m128 Extract(__m128 m, int n)
{
    switch(n)
    {
    case 0:
        return _mm_shuffle_ps(m, m, 0);
    case 1:
        return _mm_shuffle_ps(m, m, 0x55);
    case 2:
        return _mm_shuffle_ps(m, m, 0xaa);
    case 3:
        return _mm_shuffle_ps(m, m, 0xff);
    default:
        return m;
    }
}

最后是干货时间，放出Hybird3D中光栅化相关的代码供大家参考。

#include "stdafx.h"
#include "RayTracer.h"
#include "Clipper.h"
#include "PrimitiveTile.h"

#pragma warning(disable: 4018)

#define TILE_WIDTH  16
#define TILE_HEIGHT 16

const float NORMAL_THRESHOLD = 0.9f;
extern int ReflectionDepth;

_CRT_ALIGN(16) struct Illuminance
{
    Float3 direction;
    float illuminance;
    Float3 color;
    float shadowFactor;
    Illuminance* next;
    LightShader* light;
};

struct VertexOutput
{
    Float4 pos;
    Float4 normal;
    float attributes[0];
};

struct PolyPrimitive;

_CRT_ALIGN(16) struct PixelContext
{
    PixelContext* next;
    PolyPrimitive* prim;
    int triIndex;
    float alpha;
    Float4 pos;
    Float4 view;
    Float4 normal;
    Float2 uv;
    Float2 duvdx;    //d(uv) / dx
    Float2 duvdy;    //d(uv) / dy
    Illuminance* light;
    void* userData;
};

_CRT_ALIGN(16) const float FrustumClipPlane[6][4] = {
    { 0, 0, 1, 0},
    { 0, 0,-1, 1},
    { 1, 0, 0, 1},
    {-1, 0, 0, 1},
    { 0, 1, 0, 1},
    { 0,-1, 0, 1},
};

__m128 ScreenOffset;
__m128 ScreenScale;
__m128 ScreenScaleInv;

struct RenderContext : public IRenderContext
{
    Float4x4        ViewProjMatrix;
    Float4x4        ViewInvMatrix;
    Float4            _eye;
    float ScreenWidth, ScreenHeight;
    PrimitiveTile*    _primTiles;
    Bitmap*            _renderTarget;
    int                _tileCol, _tileRow;
    BYTE*            _vertexTempBuf;
    size_t            _vertexTempSize;
    ICamera*        _camera;
    Accel            _accelStruct;
    int                _aaLevel;
    int                _primCount;
    DWORD            _bkColor;
    Float4            _bkColorF;
    vector<LightShader*> _lights;

    RenderContext()
    {
        _vertexTempSize = 0;
        _vertexTempBuf = 0;
        _primTiles = 0;
        _aaLevel = 0;
        _tileCol = 0;
        _tileRow = 0;
        ScreenOffset = _mm_setr_ps(1, -1, 0, 0);
    }

    void AddLight(LightShader* light)
    {
        _lights.push_back(light);
    }

    void ClearLights()
    {
        _lights.clear();
    }

    void SetRenderTarget(Bitmap* target)
    {
        ScreenWidth = target->width;
        ScreenHeight = target->height;
        int tileCount = _tileCol * _tileRow;
        _renderTarget = target;
        _tileCol = Align(target->width, TILE_WIDTH) / TILE_WIDTH;
        _tileRow = Align(target->height, TILE_HEIGHT) / TILE_HEIGHT;
        if(tileCount < _tileCol * _tileRow)
        {
            if(_primTiles)
                delete[] _primTiles;

            _primTiles = new PrimitiveTile[_tileCol * _tileRow];
        }
        for(int i = 0; i < _tileCol * _tileRow; ++i)
            _primTiles[i].Clear();

        ScreenScale = _mm_setr_ps(ScreenWidth * 0.5f, -ScreenHeight * 0.5f, 1, 1);
        ScreenScaleInv = m128(1) / ScreenScale;
    }

    void SetAntiAliasQuality(int level)
    {
        _aaLevel = min(max(0, level), 4);
    }

    void SetCamera(ICamera* camera)
    {
        _camera = camera;
    }

    ICamera* GetCamera()
    {
        return _camera;
    }

    void VertConvert(Float4* dest, VertexOutput* vert, int vertChannels)
    {
        __m128 pos = _mm_load_ps(vert->pos);
        __m128 w = _mm_shuffle_ps(pos, pos, _MM_SHUFFLE(3, 3, 3, 3));

        __m128 rhw = _mm_div_ss(_mm_set_ss(1), w);
        rhw = _mm_shuffle_ps(rhw, rhw, 0);

        _mm_store_ps(dest[0], _mm_mul_ps(_mm_add_ps(_mm_mul_ps(pos, rhw), ScreenOffset), ScreenScale));

        __m128* attr = (__m128*)&vert->normal;
        for(int k = 0; k < vertChannels; k++)
            _mm_store_ps(dest[k + 1], _mm_mul_ps(attr[k], rhw));

        _mm_store_ss(&dest[0].w, rhw);
    }

    virtual void BeginScene()
    {
        _accelStruct.BeginBuild();
    }

    virtual void AddPolyons(VertexOutput* verts, int vertSize,
        int vertCount, DWORD* triangles, int count, Shader* shader)
    {

        _accelStruct.AddPolygons((BYTE*)verts, triangles, vertSize, vertCount, count, shader);
    }

    virtual void EndScene()
    {
        _accelStruct.Build();
    }

    virtual void SetBackground(DWORD color)
    {
        _bkColor = color;
        _bkColorF = Float4((float)(color & 0xff),
            (float)((color >> 8) & 0xff),
            (float)((color >> 16) & 0xff), 1);

        _bkColorF /= 255.f;

        _bkColorF = _bkColorF * _bkColorF;
    }

    void RasterTile(PrimitiveTile* tile, int x, int y,
        DWORD* target, int pitch, struct FGSampleTable* FGSamples = 0);

    void RasterFGSample(PrimitiveTile* tile, int x, int y, struct FGSampleMap& dest);
    
    void RasterFragmentSample(PrimitiveTile* tile, int x, int y, struct FragmentSampleMap& dest);
    
    void FGShader(struct FGSampleRef* samples, int count);

    void DrawPrimitive(TriVertex** vert, TrianglePrim& tri);

    void ClippingAndDraw(TriVertex** verts, TrianglePrim& tri);

    void DrawTriangle(TrianglePrim& tri);

    void Render();

    static void* operator new (size_t size)
    {
        return _aligned_malloc(sizeof(RenderContext), 16);
    }
};

void Create4TransPixels(PixelContext** pixels, TriPrimitive* prim, const Float4& eye,
                        float* rhw, float x, float y, Allocator& alloc)
{
    __m128 ma = _mm_loadu_ps(prim->a);
    __m128 mb = _mm_loadu_ps(prim->b);
    __m128 a0 =  ma * (m128(x - prim->p0.x)) + mb * (m128(y - prim->p0.y)) + _mm_loadu_ps(prim->c);
    for(int i = 0; i < 4; ++i)
    {
        __m128 a = a0;
        if(rhw[i] > 0)
        {
            PixelContext pixel;
            __m128 adx = a + ma;
            __m128 ady = a + mb;
            __m128 r = _mm_div_ss(m128(1), a);
            a = a * Extract(r, 0);
            adx = a - adx * Extract(_mm_rcp_ss(adx), 0);
            ady = a - ady * Extract(_mm_rcp_ss(ady), 0);
            _mm_store_ss(&pixel.pos.w, a0);
            pixel.prim = prim->prim;
            pixel.triIndex = prim->triIndex;
            _mm_storeu_ps(pixel.uv, _mm_shuffle_ps(a, adx, _MM_SHUFFLE(2, 1, 2, 1)));
            _mm_storeu_ps(pixel.duvdy, _mm_shuffle_ps(ady, ady, _MM_SHUFFLE(2, 1, 2, 1)));
            float alpha = prim->prim->shader->TransprentShader(&pixel);
            if(alpha > 0.01f)
            {
                //insert pixel
                PixelContext* p = (PixelContext*)alloc.Alloc(sizeof(PixelContext), 16);
                p->alpha = alpha;
                p->prim = prim->prim;
                p->triIndex = prim->triIndex;
                p->uv = pixel.uv;
                p->duvdx = pixel.duvdx;
                p->duvdy = pixel.duvdy;
                prim->prim->GetPosNormal(prim->triIndex, pixel.uv, &p->pos, &p->normal);
                p->view = NormalizeFast(eye - p->pos);
                p->light = 0;
                p->next = 0;
                p->pos.w = pixel.pos.w;

                float alpha2 = 1;
                if(pixels[i] == 0)
                    pixels[i] = p;
                else
                {
                    PixelContext* prev = 0;
                    PixelContext* pp = pixels[i];
                    while(pp)
                    {
                        if(p->pos.w > pp->pos.w)
                            break;
                        alpha2 -= pp->alpha;
                        prev = pp;
                        pp = pp->next;
                    }
                    p->alpha = alpha * alpha2;
                    if(prev)
                    {
                        p->next = prev->next;
                        prev->next = p;
                    }
                    else
                    {
                        p->next = pixels[i];
                        pixels[i] = p;
                    }

                    if(alpha > 0.99f)
                    {
                        p->next = 0;
                    }
                    else
                    {
                        alpha = 1 - alpha;
                        pp = p->next;
                        while(pp)
                        {
                            pp->alpha *= alpha;
                            pp = pp->next;
                        }
                    }
                }
            }
        }
        a0 = a0 + ma;
    }
}

void CreateMainPixels(PixelContext** pixels, TriPrimitive** primBuf, const Float4& eye,
                      float startX, float startY, int tileSize, float alpha, Allocator& alloc)
{
    __m128 px = m128(startX);
    __m128 py = m128(startY);
    for(int i = 0; i < tileSize; ++i)
    {
        if(i % 16 == 0 && i > 0)
        {
            py = py + m128(1);
            px = m128(startX);
        }
        TriPrimitive* prim = primBuf[i];
        if(prim)
        {
            PixelContext* p = (PixelContext*)alloc.Alloc(sizeof(PixelContext), 16);
            __m128 ma = _mm_loadu_ps(prim->a);
            __m128 mb = _mm_loadu_ps(prim->b);
            __m128 a =  ma * (px - m128(prim->p0.x)) +
                        mb * (py - m128(prim->p0.y)) + _mm_loadu_ps(prim->c);
            __m128 rhw = a;

            __m128 r = _mm_div_ss(m128(1), a);
            __m128 w = _mm_shuffle_ps(r, r, 0);
            __m128 adx = a + ma;
            __m128 ady = a + mb;
            a = a * w;
            r = _mm_rcp_ss(adx);
            adx = a - adx * _mm_shuffle_ps(r, r, 0);
            r = _mm_rcp_ss(ady);
            ady = a - ady * _mm_shuffle_ps(r, r, 0);
            _mm_storeu_ps(p->uv, _mm_shuffle_ps(a, adx,  _MM_SHUFFLE(2, 1, 2, 1)));
            _mm_storeu_ps(p->duvdy, _mm_shuffle_ps(ady, ady,  _MM_SHUFFLE(2, 1, 2, 1)));
            p->prim = prim->prim;
            p->triIndex = prim->triIndex;
            p->prim->GetPosNormal(p->triIndex, p->uv, &p->pos, &p->normal);
            p->view = NormalizeFast(eye - p->pos);
            p->light = 0;
            p->alpha = alpha;
            p->next = 0;
            pixels[i] = p;
            _mm_store_ss(&p->pos.w, rhw);
        }
        else
            pixels[i] = 0;
        px = px + m128(1);
    }
}

void InsertPixel(PixelContext** pixel, PixelContext* p)
{
    if(*pixel == 0)
        *pixel = p;
    else
    {
        PixelContext* prev = 0;
        PixelContext* pp = *pixel;
        while(pp)
        {
            if(p->pos.w > pp->pos.w)
                break;
            prev = pp;
            pp = pp->next;
        }
        if(prev)
        {
            p->next = prev->next;
            prev->next = p;
        }
        else
        {
            p->next = *pixel;
            *pixel = p;
        }
    }
}

void CreatePixels(PixelContext** pixels, TriPrimitive** primBuf, const Float4& eye,
                  float alpha, float startX, float startY, int tileSize, Allocator& alloc)
{
    __m128 px = m128(startX);
    __m128 py = m128(startY);
    for(int i = 0; i < tileSize; ++i)
    {
        if(i % 16 == 0 && i > 0)
        {
            py = py + m128(1);
            px = m128(startX);
        }
        TriPrimitive* prim = primBuf[i];
        if(prim)
        {
            PixelContext* pixel = pixels[i];
            while(pixel)
            {
                if(pixel->prim == prim->prim)
                {
                    pixel->alpha += alpha;
                    goto _SkipPixel;
                }
                pixel = pixel->next;
            }

            PixelContext* p = (PixelContext*)alloc.Alloc(sizeof(PixelContext), 16);
            __m128 ma = _mm_loadu_ps(prim->a);
            __m128 mb = _mm_loadu_ps(prim->b);

            __m128 a =  ma * (px - m128(prim->p0.x)) +
                        mb * (py - m128(prim->p0.y)) + _mm_loadu_ps(prim->c);
            __m128 rhw = a;

            __m128 r = _mm_div_ss(m128(1), a);
            __m128 w = Extract(r, 0);
            __m128 adx = a + ma;
            __m128 ady = a + mb;
            a = a * w;
            r = _mm_rcp_ss(adx);
            adx = a - adx * Extract(r, 0);
            r = _mm_rcp_ss(ady);
            ady = a - ady * Extract(r, 0);
            _mm_storeu_ps(p->uv, _mm_shuffle_ps(a, adx,  _MM_SHUFFLE(2, 1, 2, 1)));
            _mm_storeu_ps(p->duvdy, _mm_shuffle_ps(ady, ady,  _MM_SHUFFLE(2, 1, 2, 1)));
            p->prim = prim->prim;
            p->triIndex = prim->triIndex;
            p->prim->GetPosNormal(p->triIndex, p->uv, &p->pos, &p->normal);
            p->view = NormalizeFast(eye - p->pos);
            p->light = 0;
            p->alpha = alpha;
            p->next = 0;
            _mm_store_ss(&p->pos.w, rhw);
            InsertPixel(&pixels[i], p);
        }
    _SkipPixel:
        px = px + m128(1);
    }
}

void RasterFullCoverPrim(TriPrimitive* prim, float startX,
                         float startY, float* primBuf, float* wBuf)
{
    __m128 startW = m128((startX - prim->p0.x) * prim->a[0]
                    + (startY - prim->p0.y) * prim->b[0] + prim->c[0]);
    __m128 rhwDx = m128(prim->a[0] * 4);
    __m128 primData = m128(*(float*)&prim);
    startW = startW + m128(prim->a[0]) * _mm_set_ps(3, 2, 1, 0);

    for(int i = 0; i < TILE_HEIGHT; ++i)
    {
        __m128 rhw = startW;
        for(int j = 0; j < TILE_WIDTH; j += 4)
        {
            __m128 oldW = _mm_load_ps(wBuf + j);
            __m128 mask = rhw > oldW;
            _mm_store_ps(wBuf + j, Select(mask, rhw, oldW));
            _mm_store_ps(primBuf + j, Select(mask, primData, _mm_load_ps(primBuf + j)));
            rhw = rhw + rhwDx;
        }
        wBuf += TILE_WIDTH;
        primBuf += TILE_WIDTH;
        startW = startW + m128(prim->b[0]);
    }
}

void RasterPrim(TriPrimitive* prim, float x, float y,
                float xs, float ys, TriPrimitive** primBuf, float* wBuf)
{
    __m128 ex[3];
    __m128 ey[3];
    __m128 xOff[3];
    __m128 yOff[3];
    __m128 mask0[3];
    __m128 primData = m128(*(float*)&prim);

    for(int i = 0; i < 3; ++i)
    {
        ex[i] = m128(prim->ea[i]);
        ey[i] = m128(prim->eb[i]);
        xOff[i] = (ex[i] > m128(0)) & m128(4);
        yOff[i] = (ey[i] > m128(0)) & m128(4);
    }
    __m128 p0x = m128(prim->p0.x);
    __m128 p0y = m128(prim->p0.y);
    __m128 p1x = p0x - ey[0];
    __m128 p1y = p0y + ex[0];

    mask0[0] = (m128(x) - p0x) * ex[0] + (m128(y) - p0y) * ey[0];
    mask0[1] = (m128(x) - p1x) * ex[1] + (m128(y) - p1y) * ey[1];
    mask0[2] = (m128(x) - p0x) * ex[2] + (m128(y) - p0y) * ey[2];

    __m128 rhw0 = (_mm_set_ps(3, 2, 1, 0) + m128(x + xs) - p0x) * m128(prim->a[0]) +
                  (m128(y + ys) - p0y) * m128(prim->b[0]) + m128(prim->c[0]);
    __m128* mprimBuf = (__m128*)primBuf;
    __m128* mwBuf = (__m128*)wBuf;

    __m128 yStep = m128(0);
    for(int iy = 0; iy < 4; ++iy)
    {
        __m128 mask;
        __m128 xStep = _mm_set_ps(12, 8, 4, 0);
        mask =  ((mask0[0] + (xStep + xOff[0]) * ex[0] + (yStep + yOff[0]) * ey[0]) >= m128(0)) &
                ((mask0[1] + (xStep + xOff[1]) * ex[1] + (yStep + yOff[1]) * ey[1]) >= m128(0)) &
                ((mask0[2] + (xStep + xOff[2]) * ex[2] + (yStep + yOff[2]) * ey[2]) >= m128(0));

        int* imask = (int*)&mask;
        if(MoveMask(mask))
        {
            __m128 rhw1 = rhw0;
            for(int ix = 0; ix < 4; ++ix)
            {
                if(imask[ix])
                {
                    __m128 mask1[3];
                    __m128 xpos = _mm_set_ps(3, 2, 1, 0) + m128((float)(ix * 4) + xs);
                    __m128 ypos = yStep + m128(ys);
                    mask1[0] = mask0[0] + xpos * ex[0] + ypos * ey[0];
                    mask1[1] = mask0[1] + xpos * ex[1] + ypos * ey[1];
                    mask1[2] = mask0[2] + xpos * ex[2] + ypos * ey[2];

                    __m128* mprimBuf0 = mprimBuf + ix;
                    __m128* mwBuf0 = mwBuf + ix;
                    __m128 rhw = rhw1;
                    for(int j = 0; j < 4; ++j)
                    {
                        __m128 pmask =  (rhw > *mwBuf0) &
                                        (mask1[0] >= m128(0)) &
                                        (mask1[1] >= m128(0)) &
                                        (mask1[2] >= m128(0));

                        *mwBuf0 = Select(pmask, rhw, *mwBuf0);
                        *mprimBuf0 = Select(pmask, primData, *mprimBuf0);
                        mask1[0] = mask1[0] + ey[0];
                        mask1[1] = mask1[1] + ey[1];
                        mask1[2] = mask1[2] + ey[2];
                        mprimBuf0 += 4;
                        mwBuf0 += 4;
                        rhw = rhw + m128(prim->b[0]);
                    }
                }
                rhw1 = rhw1 + m128(prim->a[0]) * m128(4);
            }
        }
        rhw0 = rhw0 + m128(4) * m128(prim->b[0]);
        mprimBuf += 16;
        mwBuf += 16;
        yStep = yStep + m128(4);
    }
}

void CreateReflectRay(Ray* rays, int count, PixelContext* pixel, ReflectInfo* refInfo, const Float4& eye)
{
    if(count == 1)
    {
        Float4 pos = pixel->pos;
        Float4 normal = pixel->normal;
        Ray& ray = rays[0];

        Float4 refVec = -Normalize(Reflect(pixel->view, normal));
        pos = pos + refVec * 0.02f;
        _mm_store_ps(ray.pos, pos.m);
        _mm_store_ps(ray.dir, refVec.m);
        ray.triIndex = -1;
        ray.tmin = 0;
        ray.tmax = 1e10;
        ray.userData = refInfo;
        return;
    }

    static const Float2 offset[] = {
        Float2(0, 0),
        Float2(-0.4f, -0.4f),
        Float2(0.4f, -0.4f),
        Float2(0, 0.4f)
    };
    for(int i = 0; i < count; ++i)
    {
        Float4 pos = pixel->pos;
        Float4 normal = pixel->normal;
        Ray& ray = rays[i];

        Float4 dpos, dnormal;
        pixel->prim->GetPosNormalDifferential(pixel->triIndex, pixel->duvdx * offset[i].x, &dpos, &dnormal);
        pos = pos + dpos;
        normal = normal + dnormal;

        pixel->prim->GetPosNormalDifferential(pixel->triIndex, pixel->duvdy * offset[i].y, &dpos, &dnormal);
        pos = pos + dpos;
        normal = NormalizeFast(normal + dnormal);

        Float4 Vn;
        //Vn = pixel->view;
        Vn = NormalizeFast(eye - pos);

        Float4 refVec = -Normalize(Reflect(Vn, normal));
        pos = pos + refVec * 0.02f;
        _mm_store_ps(ray.pos, pos.m);
        _mm_store_ps(ray.dir, refVec.m);
        ray.triIndex = -1;
        ray.tmin = 0;
        ray.tmax = 1e10;
        ray.userData = refInfo;
    }
}

void CreateReflectPixel(PixelContext** pixels, Ray& ray, Allocator* alloc)
{
    ReflectInfo* refinfo = (ReflectInfo*)ray.userData;
    /*PixelContext* pixel = pixels[refinfo->index];
    while(pixel)
    {
        if(pixel->prim == ray.prim)
        {
            pixel->alpha += refinfo->strength;
            return;
        }
        pixel = pixel->next;
    }*/
    
    PixelContext* p = (PixelContext*)alloc->Alloc(sizeof(PixelContext), 16);
    p->prim = ray.prim;
    p->triIndex = ray.triIndex;
    p->uv.x = ray.u;
    p->uv.y = ray.v;

    Float4 posddx, normalddx;
    Float4 posddy, normalddy;
    refinfo->context->prim->GetPosNormalDifferential(refinfo->context->triIndex,
                                    refinfo->context->duvdx, &posddx, &normalddx);
    refinfo->context->prim->GetPosNormalDifferential(refinfo->context->triIndex,
                                    refinfo->context->duvdy, &posddy, &normalddy);

    Float2 uvdx, uvdy;
    p->prim->GetRayDifferential(ray.triIndex, *(Float4*)&ray.pos, *(Float4*)&ray.dir,
                                posddx, posddy, normalddx, normalddy, &uvdx, &uvdy);

    p->duvdx = uvdx - p->uv;
    p->duvdy = uvdy - p->uv;
    p->alpha = refinfo->strength;
    ray.prim->GetPosition(ray.triIndex, p->uv, &p->pos);
    ray.prim->GetNormal(ray.triIndex, p->uv, &p->normal);
    p->view = NormalizeFast(Float4(ray.pos, 1) - p->pos);
    p->light = 0;
    p->next = pixels[refinfo->index];
    pixels[refinfo->index] = p;
}

void CopyBuf(float* wBuf, float* wBuf2, float* primBuf, float* primBuf2, int size)
{
    for(int i = 0; i < size; i += 4)
    {
        _mm_store_ps(wBuf2 + i, _mm_load_ps(wBuf + i));
        _mm_store_ps((float*)primBuf2 + i, _mm_load_ps((float*)primBuf + i));
    }
}

float CopyBuf2(float* wBuf, float* wBuf2, float* primBuf, float* primBuf2, int size)
{
    __m128 minRHW = m128(FLT_MAX);
    for(int i = 0; i < size; i += 4)
    {
        __m128 rhw = _mm_load_ps(wBuf + i);
        minRHW = Min(minRHW, rhw);
        _mm_store_ps((float*)primBuf2 + i, _mm_load_ps((float*)primBuf + i));
        _mm_store_ps(wBuf2 + i, rhw);
    }

    minRHW = Min(Min(Extract(minRHW, 0), Extract(minRHW, 1)),
        Min(Extract(minRHW, 2), Extract(minRHW, 3)));
    float m;
    _mm_store_ss(&m, minRHW);
    return m;
}

int AACount[] = {0, 2, 4, 8, 16};
float AACfgAlpha[] = {1, 1 / 3.f, 1 / 5.f, 1 / 9.f, 1 / 17.f};
Float2 AASampler[5][16] = {
    { Float2(0, 0) },

    { Float2(0.25f, 0.25f), Float2(0.75f, 0.75f) },

    { Float2(0.25f, 0.25f), Float2(0.75f, 0.75f), Float2(0.25f, 0.75f), Float2(0.75f, 0.25f) },

    { Float2(0.2f, 0.5f), Float2(0.8f, 0.5f), Float2(0.5f, 0.2f), Float2(0.5f, 0.8f),
      Float2(0.25f, 0.25f), Float2(0.75f, 0.25f), Float2(0.25f, 0.75f), Float2(0.75f, 0.75f)},

    { Float2(0.2f, 0.2f), Float2(0.4f, 0.2f), Float2(0.6f, 0.2f), Float2(0.8f, 0.2f),
      Float2(0.2f, 0.4f), Float2(0.4f, 0.4f), Float2(0.6f, 0.4f), Float2(0.8f, 0.4f),
      Float2(0.2f, 0.6f), Float2(0.4f, 0.6f), Float2(0.6f, 0.6f), Float2(0.8f, 0.6f),
      Float2(0.2f, 0.8f), Float2(0.4f, 0.8f), Float2(0.6f, 0.8f), Float2(0.8f, 0.8f) }
};

void RenderContext::ClippingAndDraw(TriVertex** verts, TrianglePrim& tri)
{
    if(!BackCullTest((VertexOutput**)verts))
        return;

    Float4 vertTmpBuf[256];
    Float4* vertBuf = vertTmpBuf;

    int vertCount = 3;
    for(int i = 0; i < 6; i++)
    {
        vertCount = ClipPoly(*(const Float4*)FrustumClipPlane[i],
                            (VertexOutput**)verts, vertCount, 2, vertBuf);
        if(vertCount < 3)
            return;
    }

    Float4 vertsTmp[256];
    for(int i = 0; i < vertCount; i++)
        VertConvert(vertsTmp + i * 2, (VertexOutput*)verts[i], 1);

    TriVertex* triangle[3];
    for(int i = 0; i < vertCount - 2; i++)
    {
        triangle[0] = (TriVertex*)vertsTmp;
        triangle[1] = (TriVertex*)(vertsTmp + (i + 1) * 2);
        triangle[2] = (TriVertex*)(vertsTmp + (i + 2) * 2);
        DrawPrimitive(triangle, tri);
    }
}

void RenderContext::DrawTriangle(TrianglePrim& tri)
{
    TriVertex verts[3];
    verts[0].pos = Mul(tri.p0, ViewProjMatrix);
    verts[1].pos = Mul(tri.p1, ViewProjMatrix);
    verts[2].pos = Mul(tri.p2, ViewProjMatrix);
    verts[0].uv = Float4(0, 0, 0, 0);
    verts[1].uv = Float4(1, 0, 0, 0);
    verts[2].uv = Float4(0, 1, 0, 0);

    TriVertex* verts2[36];
    verts2[0] = verts;
    verts2[1] = verts + 1;
    verts2[2] = verts + 2;
    ClippingAndDraw(verts2, tri);
}

void RenderContext::RasterTile(PrimitiveTile* tile, int x, int y, DWORD* target,
                                int pitch, FGSampleTable* FGSamples)
{
    const int tileSize = TILE_WIDTH * TILE_HEIGHT;
    _CRT_ALIGN(16) TriPrimitive* primBuf[tileSize];
    _CRT_ALIGN(16) float wBuf[tileSize];
    _CRT_ALIGN(16) PixelContext* pixels[tileSize];
    //_CRT_ALIGN(16) PixelContext* mainPixels[tileSize];
    //_CRT_ALIGN(16) PixelContext* transPixels[tileSize];
    _CRT_ALIGN(16) TriPrimitive* primBuf2[tileSize];
    _CRT_ALIGN(16) float wBuf2[tileSize];
    _CRT_ALIGN(16) Float4 colorBuf[tileSize];

    Allocator allocA(Align((BYTE*)_alloca(1024 * 1024), 16), 1024 * 1024 - 15);
    Allocator allocB(Align((BYTE*)_alloca(1024 * 1024), 16), 1024 * 1024 - 15);
    Allocator* alloc = &allocA;

    tile->MergePrimitives();
    
    if(!tile->HasPrimitive())
    {
        for(int i = 0; i < tileSize; ++i)
            *((DWORD*)((BYTE*)target + pitch * (i / 16)) + (i % 16)) = _bkColor;
        return;
    }

    float startX = (float)x + 0.5f;
    float startY = (float)y + 0.5f;

    for(int i = 0; i < tileSize; i += 4)
    {
        _mm_store_ps(wBuf + i, m128(0));
        _mm_store_ps((float*)primBuf + i, m128(0));
        //_mm_store_ps((float*)pixels + i, m128(0));
        //_mm_store_ps((float*)transPixels + i, m128(0));
    }
    float farRhw = 0;
    bool hasFullPrim = false;
    while(true)
    {
        TriPrimitive* prim = tile->NextFullPrimitive();
        if(!prim)
            break;
        hasFullPrim = true;
        RasterFullCoverPrim(prim, startX, startY, (float*)primBuf, wBuf);
    }
    if(hasFullPrim)
        farRhw = CopyBuf2(wBuf, wBuf2, (float*)primBuf, (float*)primBuf2, tileSize);
    else
    {
        for(int i = 0; i < tileSize; i += 4)
        {
            _mm_store_ps(wBuf2 + i, m128(0));
            _mm_store_ps((float*)primBuf2 + i, m128(0));
        }
    }

    int aaCount = AACount[_aaLevel];
    float alpha = AACfgAlpha[_aaLevel];
    Float2* sampler = AASampler[_aaLevel];

    while(true)
    {
        TriPrimitive* prim = tile->NextOpaquePrimitive();
        if(!prim)
            break;
        if(prim->maxRhw < farRhw)
            continue;

        RasterPrim(prim, x, y, 0.5f, 0.5f, primBuf2, wBuf2);
    }
    tile->Reset();
    CreateMainPixels(pixels, primBuf2, _eye, startX, startY, tileSize, alpha, *alloc);
    farRhw = CopyBuf2(wBuf, wBuf2, (float*)primBuf, (float*)primBuf2, tileSize);
    farRhw *= 0.99f;

    for(int aa = 0; aa < aaCount; ++aa)
    {
        float xs = sampler[aa].x;
        float ys = sampler[aa].y;
        while(true)
        {
            TriPrimitive* prim = tile->NextOpaquePrimitive();
            if(!prim)
                break;
            if(prim->maxRhw < farRhw)
                continue;

            RasterPrim(prim, x, y, xs, ys, primBuf2, wBuf2);
        }
        tile->Reset();
        CreatePixels(pixels, primBuf2, _eye, alpha, startX - 0.5f + xs, startY - 0.5f + ys, tileSize, *alloc);
        CopyBuf(wBuf, wBuf2, (float*)primBuf, (float*)primBuf2, tileSize);
    }

    do
    {
        bool fullScreen;
        TriPrimitive* prim = tile->NextTransPrimitive(fullScreen);
        if(!prim)
            break;
        while(prim)
        {
            if(prim->maxRhw < farRhw)
            {
                prim = tile->NextTransPrimitive(fullScreen);
                continue;
            }
            PixelContext** tpixels = pixels;
            __m128 ex[3];
            __m128 ey[3];
            __m128 mask0[3];
            __m128 xOff[3];
            for(int i = 0; i < 3; ++i)
            {
                ex[i] = m128(prim->ea[i]);
                ey[i] = m128(prim->eb[i]);
                xOff[i] = (ex[i] > m128(0)) & m128(4);
            }

            __m128 p0x = m128(prim->p0.x);
            __m128 p0y = m128(prim->p0.y);
            __m128 p1x = p0x - ey[0];
            __m128 p1y = p0y + ex[0];

            mask0[0] = (m128(x) - p0x) * ex[0] + (m128(y + 0.5f) - p0y) * ey[0];
            mask0[1] = (m128(x) - p1x) * ex[1] + (m128(y + 0.5f) - p1y) * ey[1];
            mask0[2] = (m128(x) - p0x) * ex[2] + (m128(y + 0.5f) - p0y) * ey[2];

            __m128 rhw0 = (_mm_set_ps(3, 2, 1, 0) + m128(startX) - p0x) * m128(prim->a[0]) +
                          (m128(startY) - p0y) * m128(prim->b[0]) + m128(prim->c[0]);
            __m128* mwBuf = (__m128*)wBuf2;
            for(int iy = 0; iy < 16; ++iy)
            {
                __m128 xStep = _mm_set_ps(12, 8, 4, 0);
                __m128 mask =    ((mask0[0] + (xStep + xOff[0]) * ex[0]) >= m128(0)) &
                                ((mask0[1] + (xStep + xOff[1]) * ex[1]) >= m128(0)) &
                                ((mask0[2] + (xStep + xOff[2]) * ex[2]) >= m128(0));
                if(MoveMask(mask))
                {
                    __m128 mask1[3];
                    xStep = _mm_set_ps(3.5f, 2.5f, 1.5f, 0.5f);
                    mask1[0] = mask0[0] + xStep * ex[0];
                    mask1[1] = mask0[1] + xStep * ex[1];
                    mask1[2] = mask0[2] + xStep * ex[2];
                    __m128 rhw = rhw0;

                    for(int ix = 0; ix < 4; ++ix)
                    {
                        __m128 pmask = ((rhw > *mwBuf) &
                                        (mask1[0] >= m128(0)) &
                                        (mask1[1] >= m128(0)) &
                                        (mask1[2] >= m128(0)));
                        if(MoveMask(pmask))
                        {
                            __m128 rhw1 = rhw & pmask;
                            Create4TransPixels(tpixels, prim, _eye, (float*)&rhw1,
                                               x + ix * 4 + 0.5f, y + iy + 0.5f, *alloc);
                        }
                        rhw = rhw + m128(4) * m128(prim->a[0]);
                        mask1[0] = mask1[0] + m128(4) * ex[0];
                        mask1[1] = mask1[1]    + m128(4) * ex[1];
                        mask1[2] = mask1[2]    + m128(4) * ex[2];
                        mwBuf++;
                        tpixels += 4;
                    }
                }
                else
                {
                    mwBuf += 4;
                    tpixels += 16;
                }
                rhw0 = rhw0 + m128(prim->b[0]);
                mask0[0] = mask0[0] + ey[0];
                mask0[1] = mask0[1] + ey[1];
                mask0[2] = mask0[2] + ey[2];
            }
            prim = tile->NextTransPrimitive(fullScreen);
        }
    }while(0);

    for(int i = 0; i < tileSize; ++i)
        colorBuf[i].m = m128(0);

    Ray reflectRays[64];
    ReflectInfo refInfos[64];
    int refRayIndex = 0;
    int refInfoIndex = 0;

    for(int depth = 0; depth <= ReflectionDepth; ++depth)
    {
        bool hasReflection = false;
        for(int j = 0; j < _lights.size(); ++j)
        {
            int from, to;
            if(_lights[j]->Interpolate(&from, &to) && FGSamples)
                continue;
            _lights[j]->DirectIlluminate(pixels, tileSize, &_accelStruct, alloc);
        }
        if(FGSamples && depth == 0)
        {
            for(int i = 0; i < tileSize; ++i)
            {
                int sx = x + (i % 16);
                int sy = y + i / 16;
                PixelContext* pixel = pixels[i];
                while(pixel)
                {
                    Float4 norm;
                    pixel->prim->GetFaceNormal(pixel->triIndex, &norm);
                    
                    Float4 color = FGSamples->Lookup(pixel->prim, *(Float3*)&norm, sx, sy);
                    if(color.x + color.y + color.z > 0)
                    {
                        Illuminance* illum = (Illuminance*)alloc->Alloc(sizeof(Illuminance));
                        illum->color.x = color.x;
                        illum->color.y = color.y;
                        illum->color.z = color.z;
                        illum->direction.x = 0;
                        illum->direction.y = 0;
                        illum->direction.z = 1;
                        illum->illuminance = 1;
                        illum->light = 0;
                        illum->next = pixel->light;
                        illum->shadowFactor = 0;
                        pixel->light = illum;
                    }
                    pixel = pixel->next;
                }
            }
        }

        if(alloc == &allocA)
            alloc = &allocB;
        else
            alloc = &allocA;
        alloc->Clear();

        for(int i = 0; i < tileSize; ++i)
        {
            PixelContext* pixel = pixels[i];
            pixels[i] = 0;
            Float4 color;
            color.m = m128(0);
            float alpha = 0;

            while(pixel)
            {
                ReflectInfo reflect;
                reflect.strength = 0;
                alpha += pixel->alpha;
                color += pixel->prim->shader->PixelShader(pixel, &reflect) * pixel->alpha;
                reflect.strength *= pixel->alpha;

                if(reflect.strength > 0.01f)
                {
                    ReflectInfo& refInfo = refInfos[refInfoIndex++];
                    refInfo = reflect;
                    refInfo.context = pixel;
                    refInfo.index = i;
                    refInfo.strength *= 0.25f;

                    if(depth == 0)
                    {
                        CreateReflectRay(reflectRays + refRayIndex, 4, pixel, &refInfo, _eye);
                        refRayIndex += 4;
                    }
                    else
                    {
                        CreateReflectRay(reflectRays + refRayIndex, 4, pixel, &refInfo, _eye);
                        refRayIndex += 4;
                    }
                    hasReflection = true;

                    if(refRayIndex >= 64)
                    {
                        _accelStruct.TraceIntersect(reflectRays, refRayIndex);
                        for(int r = 0; r < refRayIndex; ++r)
                        {
                            Ray& ray = reflectRays[r];
                            if(ray.prim)
                                CreateReflectPixel(pixels, ray, alloc);
                        }
                        refInfoIndex = 0;
                        refRayIndex = 0;
                    }
                }
                pixel = pixel->next;
            }
            if(refRayIndex > 0)
            {
                _accelStruct.TraceIntersect(reflectRays, refRayIndex);
                for(int r = 0; r < refRayIndex; ++r)
                {
                    Ray& ray = reflectRays[r];
                    if(ray.prim)
                        CreateReflectPixel(pixels, ray, alloc);
                }
                refInfoIndex = 0;
                refRayIndex = 0;
            }
            if(depth == 0)
            {
                if(alpha < 0.99f)
                    color = color + _bkColorF * (1 - alpha);
                colorBuf[i] = color;
            }
            else
                colorBuf[i] += color;
        }

        if(!hasReflection)
            break;
    }

    for(int i = 0; i < tileSize; ++i)
    {
        __m128i icolor = _mm_cvttps_epi32(_mm_rsqrt_ps(colorBuf[i].m) * colorBuf[i].m * m128(255));
        icolor = _mm_packs_epi32(icolor, icolor);
        icolor = _mm_packus_epi16(icolor, icolor);
        
        *((DWORD*)((BYTE*)target + pitch * (i / 16)) + (i % 16)) = _mm_cvtsi128_si32(icolor);
    }
}

void RenderContext::DrawPrimitive(TriVertex** p, TrianglePrim& tri)
{
    if((p[2]->pos.x - p[0]->pos.x) * (p[1]->pos.y - p[0]->pos.y)
        - (p[1]->pos.x - p[0]->pos.x) * (p[2]->pos.y - p[0]->pos.y) <= 0)
        return;

    Float3 edge[3];
    edge[0] = CalcEdge(p[0]->pos, p[1]->pos);
    edge[1] = CalcEdge(p[1]->pos, p[2]->pos);
    edge[2] = CalcEdge(p[2]->pos, p[0]->pos);

    TriPrimitive* prim = (TriPrimitive*)MemoryHeapMT::Alloc(sizeof(TriPrimitive));
    prim->prim = tri.prim;
    prim->maxRhw = max(max(p[0]->pos.w, p[1]->pos.w), p[2]->pos.w);
    prim->triIndex = tri.triIndex;
    prim->p0.x = p[0]->pos.x;
    prim->p0.y = p[0]->pos.y;
    for(int i = 0; i < 3; ++i)
    {
        prim->ea[i] = -edge[i].x;
        prim->eb[i] = -edge[i].y;
        //prim->edge[i].x = -edge[i].x;
        //prim->edge[i].y = -edge[i].y;
    }
    __m128 A = m128(1 / ((p[0]->pos.x - p[1]->pos.x) * (p[0]->pos.y - p[2]->pos.y)
                    - (p[0]->pos.y - p[1]->pos.y) * (p[0]->pos.x - p[2]->pos.x)));
    __m128 attr[3];
    for(int i = 0; i < 3; ++i)
        attr[i] = _mm_loadu_ps(&p[i]->pos.w);

    _mm_storeu_ps(prim->a, A * (m128(edge[0].x) * attr[2] + m128(edge[1].x) * attr[0] + m128(edge[2].x) * attr[1]));
    _mm_storeu_ps(prim->b, A * (m128(edge[0].y) * attr[2] + m128(edge[1].y) * attr[0] + m128(edge[2].y) * attr[1]));
    prim->c[0] = p[0]->pos.w;
    prim->c[1] = p[0]->uv.x;
    prim->c[2] = p[0]->uv.y;

    __m128 maxP = Min(Max(Max(p[0]->pos.m, p[1]->pos.m), p[2]->pos.m) + m128(1.5f),
                      _mm_set_ps(0, 0, ScreenHeight, ScreenWidth));
    __m128 minP = Max(Min(Min(p[0]->pos.m, p[1]->pos.m), p[2]->pos.m) - m128(0.5f), m128(0));

    __m128i bound = _mm_cvtps_epi32(_mm_unpacklo_ps(minP, maxP));

    bound = _mm_add_epi32(bound, _mm_set_epi32(TILE_HEIGHT - 1, 0, TILE_WIDTH - 1, 0));
    bound = _mm_and_si128(bound, _mm_set_epi32(~(TILE_HEIGHT - 1),
                          ~(TILE_HEIGHT - 1), ~(TILE_WIDTH - 1), ~(TILE_WIDTH - 1)));

    edge[0] = -edge[0];
    edge[1] = -edge[1];
    edge[2] = -edge[2];

    const int& minX = ((int*)&bound)[0];
    const int& maxX = ((int*)&bound)[1];
    const int& minY = ((int*)&bound)[2];
    const int& maxY = ((int*)&bound)[3];

    __m128 offX, offY;
    __m128 ex = _mm_set_ps(0, edge[2].x, edge[1].x, edge[0].x);
    __m128 ey = _mm_set_ps(0, edge[2].y, edge[1].y, edge[0].y);
    __m128 ez = _mm_set_ps(0, edge[2].z, edge[1].z, edge[0].z);
    offX = (ex > m128(0)) & m128(TILE_WIDTH);
    offY = (ey > m128(0)) & m128(TILE_HEIGHT);

    PrimitiveTile* tile = _primTiles + (minY / TILE_HEIGHT) * _tileCol + (minX / TILE_WIDTH);

    bool trans = tri.prim->shader->IsTransprency();

    for(int y = minY; y < maxY; y += TILE_HEIGHT)
    {
        PrimitiveTile* tile2 = tile;
        for(int x = minX; x < maxX; x += TILE_WIDTH)
        {
            if(MoveMask((m128(x) + offX) * ex + (m128(y) + offY) * ey + ez) == 0)
            {
                bool fullCovered = MoveMask((m128(x + TILE_WIDTH) - offX) * ex
                                    + (m128(y + TILE_HEIGHT) - offY) * ey + ez) == 0;
                if(trans)
                {
                    tile2->AddPrimitive(prim, Tanslusent, fullCovered);
                }
                else
                {
                    if(fullCovered)
                        tile2->InsertFullPrimitive(prim, prim->maxRhw);
                    else
                        tile2->AddPrimitive(prim, Opaque, false);
                }
            }
            tile2++;
        }
        tile += _tileCol;
    }
}

void RenderContext::Render()
{
    ViewProjMatrix = _camera->GetViewProjMatrix();
    _eye = Float4(_camera->GetEyePos(), 1);
    DWORD startTime = ::timeGetTime();

    struct VertexProcess
    {
        LONG index;
        RenderContext* rc;
        TrianglePrim* prims;
        int triCount;

        static void Run(int id, void* _context)
        {
            VertexProcess* context = (VertexProcess*)_context;
            RenderContext* rc = context->rc;
                
            while(true)
            {
                LONG index = ::InterlockedIncrement(&context->index) - 1;
                int c = index * 64;
                if(c >= context->triCount)
                    break;
                int e = min(c + 64, context->triCount);
                for(int i = c; i < e; ++i)
                    rc->DrawTriangle(context->prims[i]);
            }
        }

        VertexProcess()
        {
            index = 0;
        }
    };

    VertexProcess p;
    p.rc = this;
    p.prims = _accelStruct.GetPrims(&p.triCount);
    Parallel::Run(VertexProcess::Run, &p);

    LogInfo("Vertex Process time: %d\n", ::timeGetTime() - startTime);
    startTime = ::timeGetTime();


    struct PixelProcess
    {
        LONG index;
        RenderContext* rc;

        static void Run(int id, void* _context)
        {
            PixelProcess* context = (PixelProcess*)_context;
            RenderContext* rc = context->rc;
            while(true)
            {
                LONG index = ::InterlockedIncrement(&context->index) - 1;
                if(index >= (rc->_tileCol * rc->_tileRow))
                    break;

                int col = index % (rc->_tileCol);
                int row = index / (rc->_tileCol);

                int x = col * TILE_WIDTH;
                int y = row * TILE_HEIGHT;
                index = row * rc->_tileCol + col;

                rc->RasterTile(rc->_primTiles + index, x, y,
                    (*rc->_renderTarget)[y] + x, rc->_renderTarget->pitch);
            }
        }

        PixelProcess()
        {
            index = 0;
        }
    };

    PixelProcess pp;
    pp.rc = this;
    Parallel::Run(PixelProcess::Run, &pp);

    LogInfo("Pixel Process time: %d\n", ::timeGetTime() - startTime);
}