path: root/src/prenderer.cpp

#if SPECIAL
#include "main.h"
#endif

static v2
T_CompPosToLayerPos(layer_transforms T, uint32 FileWidth, uint32 FileHeight, uint32 SourceWidth, uint32 SourceHeight, real32 X, real32 Y)
{
    real32 Rad = (T.rotation* (PI / 180));
    v2 XAxis = (SourceWidth *   T.scale)*V2(cos(Rad), sin(Rad));
    v2 YAxis = (SourceHeight * -T.scale)*V2(sin(Rad), -cos(Rad));

    v2 Pos = {T.x, T.y};
    v2 Origin = Pos - (XAxis * T.ax) - (YAxis * T.ay);

    v2 XAxisPerp = (1.0f / LengthSq(XAxis))*XAxis;
    v2 YAxisPerp = (1.0f / LengthSq(YAxis))*YAxis;

    real32 StartVectorX = X - Origin.x;
    real32 StartVectorY = Y - Origin.y;
    real32 LayerU = (StartVectorX * XAxisPerp.x) + (StartVectorY * XAxisPerp.y);
    real32 LayerV = (StartVectorX * YAxisPerp.x) + (StartVectorY * YAxisPerp.y);
    return V2(LayerU * SourceWidth, LayerV * SourceHeight);
}

static v2
T_CompUVToLayerUV(layer_transforms T, uint32 FileWidth, uint32 FileHeight, uint32 SourceWidth, uint32 SourceHeight, v2 CompUV)
{
    real32 X = CompUV.x*FileWidth;
    real32 Y = CompUV.y*FileHeight;

    real32 Rad = (T.rotation* (PI / 180));
    v2 XAxis = (SourceWidth *   T.scale)*V2(cos(Rad), sin(Rad));
    v2 YAxis = (SourceHeight * -T.scale)*V2(sin(Rad), -cos(Rad));

    v2 Pos = {T.x, T.y};
    v2 Origin = Pos - (XAxis * T.ax) - (YAxis * T.ay);

    v2 XAxisPerp = (1.0f / LengthSq(XAxis))*XAxis;
    v2 YAxisPerp = (1.0f / LengthSq(YAxis))*YAxis;

    real32 StartVectorX = X - Origin.x;
    real32 StartVectorY = Y - Origin.y;
    real32 LayerU = (StartVectorX * XAxisPerp.x) + (StartVectorY * XAxisPerp.y);
    real32 LayerV = (StartVectorX * YAxisPerp.x) + (StartVectorY * YAxisPerp.y);
    return V2(LayerU, LayerV);
}

static v2
T_CompPosToLayerPos(layer_transforms T, uint32 FileWidth, uint32 FileHeight, uint32 SourceWidth, uint32 SourceHeight, v2 CompUV)
{
    v2 UV = T_CompUVToLayerUV(T, FileWidth, FileHeight, SourceWidth, SourceHeight, CompUV/V2(FileWidth, FileHeight));
    return UV*V2(SourceWidth, SourceHeight);
}

static v2
Transform_ScreenSpaceToLocal(layer_transforms T, uint32 FileWidth, uint32 FileHeight, uint32 SourceWidth, uint32 SourceHeight,
                             ImVec2 CompPos, ImVec2 CompZoom, ImVec2 ViewportMin, ImVec2 Point)
{
    v2 CompUV =  ImGui_ScreenPointToCompUV(ViewportMin, CompPos, CompZoom, Point);
    v2 LayerUV = T_CompUVToLayerUV(T, FileWidth, FileHeight, SourceWidth, SourceHeight, CompUV);
    return V2(LayerUV.x * SourceWidth, LayerUV.y * SourceHeight);
}

// Transform given data based on state's Interact data.
static void
Transform_ApplyLocal(interact_transform Interact, v2 Position, v2 Center,
                    real32 *OutputX, real32 *OutputY, real32 *OutputRotation, real32 *OutputScale)
{
    real32 Point0X = Center.x - *OutputX;
    real32 Point0Y = Center.y - *OutputY;

    real32 Rad = Interact.Radians;
    real32 Rotation = Rad / (PI / 180);

    v2 XAxis = (Point0X *  Interact.Scale)*V2(cos(Rad),  sin(Rad));
    v2 YAxis = (Point0Y * -Interact.Scale)*V2(sin(Rad), -cos(Rad));

    real32 X0 = -XAxis.x - YAxis.x + Center.x;
    real32 Y0 = -XAxis.y - YAxis.y + Center.y;

    *OutputX = X0 + Position.x;
    *OutputY = Y0 + Position.y;
    *OutputRotation += Rotation;
    *OutputScale *= Interact.Scale;
}

// TODO(fox): Clean up function to do the RadianOffset rotation earlier in the loops of where the function is called
static void
Transform_ApplyInteractive(interact_transform Interact, real32 *OutputX, real32 *OutputY, real32 *OutputRotation, real32 *OutputScale)
{
    v2 BoxLength = Interact.Max - Interact.Min;
    v2 Center = Interact.Max - (BoxLength/2);
    if (Interact.RadianOffset != 0.0f) {
        v2 LocalCenter = Interact.NewCenter;
        real32 Rad = Interact.RadianOffset;
        real32 Point0X = Center.x - Interact.OGCenter.x;
        real32 Point0Y = Center.y - Interact.OGCenter.y;
        v2 XAxis = (Point0X * 1.0f)*V2(cos(Rad), sin(Rad));
        v2 YAxis = (Point0Y * 1.0f)*V2(sin(Rad), -cos(Rad));
        Center = Interact.OGCenter + XAxis + YAxis;
    }

    Transform_ApplyLocal(Interact, Interact.Position, Center, OutputX, OutputY, OutputRotation, OutputScale);
}

static v2
TransformVec(layer_transforms T, real32 Width, real32 Height, v2 Point)
{
    real32 Rad = (T.rotation * (PI / 180));
    v2 XAxis = Point.x *  T.scale  * V2(cos(Rad), sin(Rad));
    v2 YAxis = Point.y * -T.scale  * V2(sin(Rad), -cos(Rad));
    v2 LocalPoint = XAxis + YAxis;
    return V2(LocalPoint.x, LocalPoint.y);
}

static void
Transform_IterateOuterBounds(block_layer *Layer, uint32 Width, uint32 Height, real32 *MinX, real32 *MinY, real32 *MaxX, real32 *MaxY)
{
    real32 Rad = (Layer->rotation.CurrentValue * (PI / 180));
    real32 s = Layer->scale.CurrentValue;

    v2 XAxis = (Width * s)*V2(cos(Rad), sin(Rad));
    v2 YAxis = (Height * -s)*V2(sin(Rad), -cos(Rad));

    real32 AnchorX = Layer->ax.CurrentValue;
    real32 AnchorY = Layer->ay.CurrentValue;

    v2 Pos = {Layer->x.CurrentValue, Layer->y.CurrentValue};
    v2 Origin = Pos - (XAxis * AnchorX) - (YAxis * AnchorY);

    real32 XLengthSq = 1.0f / LengthSq(XAxis);
    real32 YLengthSq = 1.0f / LengthSq(YAxis);

    v2 Points[4] = {Origin, Origin + XAxis, Origin + YAxis, Origin + XAxis + YAxis};
    for (int i = 0; i < 4; i++) {
        if (Points[i].x < *MinX) { *MinX = Points[i].x; }
        if (Points[i].y < *MinY) { *MinY = Points[i].y; }
        if (Points[i].x > *MaxX) { *MaxX = Points[i].x; }
        if (Points[i].y > *MaxY) { *MaxY = Points[i].y; }
    }
}
static void
Transform_Recurse(project_state *State, memory *Memory, block_composition *MainComp, uint32 CompIndex, block_layer *ParentLayer[4], uint32 Recursions,
                      sorted_comp_array *SortedCompArray, sorted_layer_array *SortedLayerArray,
                      real32 *MinX, real32 *MinY, real32 *MaxX, real32 *MaxY)
{
    sorted_comp_array *SortedCompStart = &SortedCompArray[CompIndex];
    sorted_layer_array *SortedLayerStart = Sorted_GetLayerStart(SortedLayerArray, SortedCompArray, CompIndex);
    for (int i = 0; i < SortedCompStart->LayerCount; i++)
    {
        sorted_layer_array SortEntry = SortedLayerStart[i];
        uint32 Index_Physical = SortEntry.Block_Layer_Index;
        block_layer *Layer = (block_layer *)Memory_Block_AddressAtIndex(Memory, F_Layers, Index_Physical);
        if (Layer->IsPrecomp) {
            ParentLayer[Recursions] = Layer;
            Transform_Recurse(State, Memory, MainComp, Layer->Block_Source_Index, ParentLayer, Recursions + 1, SortedCompArray, SortedLayerArray,
                              MinX, MinY, MaxX, MaxY);
        }
        if (Layer->IsSelected & 0x01) {
            int Width = 0, Height = 0;
            Layer_GetDimensions(Memory, Layer, &Width, &Height);

            v2 Point[5] = { V2(Width*Layer->ax.CurrentValue, Height*Layer->ay.CurrentValue), V2(0, 0), V2(Width, 0), V2(0, Height), V2(Width, Height) };

            layer_transforms T = Layer_GetTransforms(Layer);

            v2 NewPos[5];
            for (int i = 0; i < 5; i++) {
                NewPos[i] = TransformPoint(T, Width, Height, Point[i]);
            }

            int i = 0;
            while (i < Recursions) {
                T = Layer_GetTransforms(ParentLayer[i]);
                block_composition *Comp = (block_composition *)Memory_Block_AddressAtIndex(Memory, F_Precomps, ParentLayer[i]->Block_Source_Index);
                Width = Comp->Width;
                Height = Comp->Height;
                for (int i = 0; i < 5; i++) {
                    NewPos[i] = TransformPoint(T, Width, Height, NewPos[i]);
                }
                i++;
            }

            for (int i = 0; i < 4; i++) {
                if (NewPos[i+1].x < *MinX) { *MinX = NewPos[i+1].x; }
                if (NewPos[i+1].y < *MinY) { *MinY = NewPos[i+1].y; }
                if (NewPos[i+1].x > *MaxX) { *MaxX = NewPos[i+1].x; }
                if (NewPos[i+1].y > *MaxY) { *MaxY = NewPos[i+1].y; }
            }
        }
    }
}

static v2
TransformPoint(layer_transforms T, real32 Width, real32 Height, v2 Point)
{
    real32 Rad = (T.rotation * (PI / 180));
    v2 XAxis = (Point.x - T.ax*Width)  * T.scale  * V2(cos(Rad), sin(Rad));
    v2 YAxis = (Point.y - T.ay*Height) * -T.scale * V2(sin(Rad), -cos(Rad));
    v2 LocalPoint = XAxis + YAxis;
    return V2(T.x + LocalPoint.x, T.y + LocalPoint.y);
}

static layer_transforms
Transform_Inverse(layer_transforms T)
{
    T.x = -T.x;
    T.y = -T.y;
    T.ax = -T.ax;
    T.ay = -T.ay;
    T.rotation = T.rotation;
    T.scale = 1.0f;
    return T;
}

static layer_transforms 
Transform_TestInteracts(project_state *State, block_layer *Layer, sorted_layer_array SortEntry, layer_transforms T)
{
    if (State->Interact_Active == interact_type_viewport_transform && Layer->IsSelected & 0x01) {
        T.x += State->Interact_Offset[0];
        T.y += State->Interact_Offset[1];
        real32 Rand = State->Interact_Offset[3];
    }
    if (State->Interact_Active == interact_type_viewport_transform_gizmo && Layer->IsSelected & 0x01) {
        Transform_ApplyInteractive(State->Interact_Transform, &T.x, &T.y, &T.rotation, &T.scale);
    }
    if (State->Interact_Active == interact_type_viewport_slide && Layer->IsSelected & 0x01) {
        // Transform_ApplySlide((v2 *)&State->Interact_Offset[0], &T);
    }
    if (State->Interact_Active == interact_type_viewport_duplicate && SortEntry.IsFake) {
        Assert(Layer->IsSelected & 0x01);
        T.x += State->Interact_Offset[0];
        T.y += State->Interact_Offset[1];
    }
    return T;
}

static layer_transforms
Transform_Add(layer_transforms T, layer_transforms ExtraT, real32 Width, real32 Height)
{
    v2 NewPos = TransformPoint(ExtraT, Width, Height, V2(T.x, T.y));
    T.x = NewPos.x;
    T.y = NewPos.y;
    T.ax = T.ax;
    T.ay = T.ay;
    T.rotation = T.rotation + ExtraT.rotation;
    T.scale = T.scale * ExtraT.scale;
    return T;
}

static layer_transforms
Transform_Add2(layer_transforms T, layer_transforms ExtraT, real32 Width, real32 Height)
{
    v2 NewPos = TransformPoint(ExtraT, Width, Height, V2(T.x, T.y));
    T.x = NewPos.x;
    T.y = NewPos.y;
    T.ax = T.ax;
    T.ay = T.ay;
    T.rotation = T.rotation + ExtraT.rotation;
    T.scale = T.scale / ExtraT.scale;
    return T;
}

static ImVec2
Layer_LocalToScreenSpace(project_state *State, memory *Memory, block_layer *Layer, ui *UI, uint32 PrincipalCompIndex, v2 Point)
{
    block_composition *MainComp = (block_composition *)Memory_Block_AddressAtIndex(Memory, F_Precomps, PrincipalCompIndex);

    uint32 Width = 0, Height = 0;
    if (!Layer->IsPrecomp) {
        block_source *Source = (block_source *)Memory_Block_AddressAtIndex(Memory, F_Sources, Layer->Block_Source_Index);
        Width = Source->Width;
        Height = Source->Height;
    } else {
        block_composition *Comp = (block_composition *)Memory_Block_AddressAtIndex(Memory, F_Precomps, Layer->Block_Source_Index);
        Width = Comp->Width;
        Height = Comp->Height;
    }

    layer_transforms T = Layer_GetTransforms(Layer);

    if ((State->Interact_Active == interact_type_viewport_transform ||
        State->Interact_Active == interact_type_viewport_transform_gizmo) && Layer->IsSelected & 0x01) {
        Transform_ApplyInteractive(State->Interact_Transform, &T.x, &T.y, &T.rotation, &T.scale);
    }

    v2 NewPos = TransformPoint(T, Width, Height, Point);

    if (Layer->Block_Composition_Index != PrincipalCompIndex) {
        layer_transforms T = Layer_GetTransforms(Layer);
        NewPos = TransformPoint(T, Width, Height, NewPos);
    }

    v2 CompUV = NewPos / V2(MainComp->Width, MainComp->Height);

    v2 ScreenPoint = V2(UI->CompPos.x + CompUV.x * UI->CompZoom.x,
                        UI->CompPos.y + CompUV.y * UI->CompZoom.y);

    return ImVec2(ScreenPoint.x, ScreenPoint.y);
}

static void
Fallback_RenderLayer(transform_info T, void *OutputBuffer, rectangle RenderRegion);
static void
Fallback_RenderDirect(direct_info T, void *OutputBuffer, rectangle RenderRegion);

static void
RenderLayers(render_entry Entry) {
    switch (Entry.RenderType)
    {
        case render_type_main:
        {
            Fallback_RenderLayer(*(transform_info *)Entry.RenderData, Entry.OutputBuffer, Entry.RenderRegion);
        } break;
        case render_type_notransform:
        {
            Fallback_RenderDirect(*(direct_info *)Entry.RenderData, Entry.OutputBuffer, Entry.RenderRegion);
        } break;
        case render_type_notransform_swap:
        {
            Fallback_RenderDirect(*(direct_info *)Entry.RenderData, Entry.OutputBuffer, Entry.RenderRegion);
        } break;
        case render_type_brush:
        {
            PaintTest(*(brush_info *)Entry.RenderData, Entry.OutputBuffer, Entry.RenderRegion);
        } break;
        default:
        {
            Assert(0);
        }
    }
#if 0
#if ARM
    Fallback_RenderLayer(RenderData->TransformInfo[i], RenderInfo->CompBuffer, RenderRegion);
#else
    if (InstructionMode == instruction_mode_avx)
        AVX2_RenderLayer(Entry.T, Entry.OutputBuffer, Entry.RenderRegion);
    else
        Fallback_RenderLayer(Entry.T, Entry.OutputBuffer, Entry.RenderRegion);
#endif
#endif
}

static void
Renderer_Start(void *Data, void *OutputBuffer, render_type RenderType, rectangle RenderRegion)
{
#if DEBUG
    if (Debug.NoThreading) {
        render_entry Entry = { Data, OutputBuffer, RenderType, RenderRegion };
        RenderLayers(Entry);
        return;
    }
#endif
    // CPU
    Threading_BitmapOp(Data, OutputBuffer, RenderType, RenderRegion);
}

static void
Renderer_Check(bool32 *Test, render_type RenderType)
{
#if DEBUG
    if (Debug.NoThreading) {
        *Test = true;
        return;
    }
#endif
    // CPU
    *Test = Threading_IsActive(RenderType);
}


static transform_info
Transform_Calculate(project_state *State, memory *Memory, project_data *File, block_layer *Layer, block_composition *Comp,
                    int Width, int Height, int BytesPerPixel)
{
    transform_info TransformInfo;

    real32 Rotation = Layer->rotation.CurrentValue;
    real32 X = Layer->x.CurrentValue;
    real32 Y = Layer->y.CurrentValue;
    real32 s = Layer->scale.CurrentValue;
    blend_mode BlendMode = Layer->BlendMode;

    if ((State->Interact_Active == interact_type_viewport_transform ||
        State->Interact_Active == interact_type_viewport_transform_gizmo) && Layer->IsSelected & 0x01) {
        Transform_ApplyInteractive(State->Interact_Transform, &X, &Y, &Rotation, &s);
    }

    /*
    state_file_ui *UI = &State->Context[State->CurrentFileIndex].UI;
    if (UI->IsInteracting == true && UI->InteractMode == interact_transforms && Layer->IsSelected && !Layer->IsAdjustment)
        Transform_ApplyInteractive(UI, &X, &Y, &Rotation, &s);

    if (UI->IsInteractingBlendmode == true && Layer->IsSelected)
        BlendMode = UI->InteractBlendmode;
        */

    real32 Rad = (Rotation * (PI / 180));
    // v2 Scale = {Source->Raster.Width * s, Source->Raster.Height * s};

    v2 XAxis = (Width * s)*V2(cos(Rad), sin(Rad));
    v2 YAxis = (Height * -s)*V2(sin(Rad), -cos(Rad));

    real32 AnchorX = Layer->ax.CurrentValue;
    real32 AnchorY = Layer->ay.CurrentValue;

    v2 Pos = {X, Y};
    v2 Origin = Pos - (XAxis * AnchorX) - (YAxis * AnchorY);

    real32 XLengthSq = 1.0f / LengthSq(XAxis);
    real32 YLengthSq = 1.0f / LengthSq(YAxis);

    int32 MaxX = 0;
    int32 MaxY = 0;
    int32 MinX = Comp->Width;
    int32 MinY = Comp->Height;

    v2 Points[4] = {Origin, Origin + XAxis, Origin + YAxis, Origin + XAxis + YAxis};
    for (int i = 0; i < 4; i++) {
        if (Points[i].x < MinX) { MinX = Points[i].x; }
        if (Points[i].y < MinY) { MinY = Points[i].y; }
        if (Points[i].x > MaxX) { MaxX = Points[i].x; }
        if (Points[i].y > MaxY) { MaxY = Points[i].y; }
    }
    TransformInfo.XAxisPX = XLengthSq*XAxis.x;
    TransformInfo.XAxisPY = XLengthSq*XAxis.y;
    TransformInfo.YAxisPX = YLengthSq*YAxis.x;
    TransformInfo.YAxisPY = YLengthSq*YAxis.y;

    TransformInfo.BufferWidth = Comp->Width;
    TransformInfo.BufferHeight = Comp->Height;
    TransformInfo.BufferBytesPerPixel = Comp->BytesPerPixel;
    TransformInfo.BufferBits = Bitmap_ByteInfo(Comp->BytesPerPixel);

    TransformInfo.LayerWidth = Width;
    TransformInfo.LayerHeight = Height;
    TransformInfo.LayerBytesPerPixel = BytesPerPixel;
    TransformInfo.LayerBits = Bitmap_ByteInfo(BytesPerPixel);

    TransformInfo.LayerOpacity = Layer->opacity.CurrentValue;
    TransformInfo.BlendMode = BlendMode;
    TransformInfo.OriginX = Origin.x;
    TransformInfo.OriginY = Origin.y;
    TransformInfo.BufferPitch = Comp->Width*Comp->BytesPerPixel;
    TransformInfo.LayerPitch = Width*BytesPerPixel;
    TransformInfo.ClipRect = {MinX, MinY, MaxX, MaxY};

    TransformInfo.IsAdjustment = Layer->IsAdjustment;

    return TransformInfo;
}

// NOTE(fox): is this too ridiculous? i don't trust inline
#define Fallback_Blend() \
        switch (T.BlendMode)\
        {\
            case blend_normal:\
            {\
            } break;\
            case blend_multiply:\
            {\
                R_Blend  = R_Dest * R_Col;\
                G_Blend  = G_Dest * G_Col;\
                B_Blend  = B_Dest * B_Col;\
            } break;\
            case blend_colorburn:\
            {\
                /* NOTE(fox): Padding to prevent actual crashing from zero division */ \
                R_Blend = 1.0f - ((1.0f - R_Dest) / (R_Col + 0.001f));\
                G_Blend = 1.0f - ((1.0f - G_Dest) / (G_Col + 0.001f));\
                B_Blend = 1.0f - ((1.0f - B_Dest) / (B_Col + 0.001f));\
            } break;\
            case blend_linearburn:\
            {\
                R_Blend = (R_Dest + R_Col) - 1.0f;\
                G_Blend = (G_Dest + G_Col) - 1.0f;\
                B_Blend = (B_Dest + B_Col) - 1.0f;\
            } break;\
            case blend_add:\
            {\
                R_Blend = R_Dest + R_Col;\
                G_Blend = G_Dest + G_Col;\
                B_Blend = B_Dest + B_Col;\
            } break;\
            case blend_screen:\
            {\
                R_Blend  = 1.0f - ((1.0f - R_Dest) * (1.0f - R_Col));\
                G_Blend  = 1.0f - ((1.0f - G_Dest) * (1.0f - G_Col));\
                B_Blend  = 1.0f - ((1.0f - B_Dest) * (1.0f - B_Col));\
            } break;\
            case blend_overlay:\
            {\
                if (R_Dest < 0.5) {\
                    R_Blend = 2.0f * R_Dest * R_Col;\
                } else {\
                    R_Blend = 1.0f - (2.0f * (1.0f - R_Dest) * (1.0f - R_Col));\
                }\
                if (G_Dest < 0.5) {\
                    G_Blend = 2.0f * G_Dest * G_Col;\
                } else {\
                    G_Blend = 1.0f - (2.0f * (1.0f - G_Dest) * (1.0f - G_Col));\
                }\
                if (B_Dest < 0.5) {\
                    B_Blend = 2.0f * B_Dest * B_Col;\
                } else {\
                    B_Blend = 1.0f - (2.0f * (1.0f - B_Dest) * (1.0f - B_Col));\
                }\
            } break;\
            case blend_softlight:\
            {\
                /* using Pegtop's equation */  \
                R_Blend = ((1.0f - R_Col * 2) * R_Dest * R_Dest) + (R_Col * 2 * R_Dest);\
                G_Blend = ((1.0f - G_Col * 2) * G_Dest * G_Dest) + (G_Col * 2 * G_Dest);\
                B_Blend = ((1.0f - B_Col * 2) * B_Dest * B_Dest) + (B_Col * 2 * B_Dest);\
            } break;\
            case blend_hardlight:\
            {\
                if (R_Dest > 0.5) {\
                    R_Blend = 2.0f * R_Dest * R_Col;\
                } else {\
                    R_Blend = 1.0f - (2.0f * (1.0f - R_Dest) * (1.0f - R_Col));\
                }\
                if (G_Dest > 0.5) {\
                    G_Blend = 2.0f * G_Dest * G_Col;\
                } else {\
                    G_Blend = 1.0f - (2.0f * (1.0f - G_Dest) * (1.0f - G_Col));\
                }\
                if (B_Dest > 0.5) {\
                    B_Blend = 2.0f * B_Dest * B_Col;\
                } else {\
                    B_Blend = 1.0f - (2.0f * (1.0f - B_Dest) * (1.0f - B_Col));\
                }\
            } break;\
            case blend_subtract:\
            {\
                R_Blend = R_Dest - R_Col;\
                G_Blend = G_Dest - G_Col;\
                B_Blend = B_Dest - B_Col;\
            } break;\
            case blend_divide:\
            {\
                R_Blend = R_Dest / (R_Col + 0.001f);\
                G_Blend = G_Dest / (G_Col + 0.001f);\
                B_Blend = B_Dest / (B_Col + 0.001f);\
            } break;\
            case blend_difference:\
            {\
                if (R_Col - R_Dest > 0) {\
                    R_Blend = R_Col - R_Dest;\
                } else {\
                    R_Blend = R_Dest - R_Col;\
                }\
                if (G_Col - G_Dest > 0) {\
                    G_Blend = G_Col - G_Dest;\
                } else {\
                    G_Blend = G_Dest - G_Col;\
                }\
                if (B_Col - B_Dest > 0) {\
                    B_Blend = B_Col - B_Dest;\
                } else {\
                    B_Blend = B_Dest - B_Col;\
                }\
            } break;\
        }\

static void
Fallback_RenderDirect(direct_info T, void *OutputBuffer, rectangle RenderRegion)
{
    rectangle LayerBounds = ClipRectangle( T.ClipRect, RenderRegion);

    Assert(LayerBounds.Max.x <= T.BufferWidth);
    Assert(LayerBounds.Max.y <= T.BufferHeight);

    for (int16 Y = LayerBounds.Min.y; Y < LayerBounds.Max.y; Y++)
    {
        for (int16 X = LayerBounds.Min.x; X < LayerBounds.Max.x; X++)
        {
            uint16 LX = X;
            uint16 LY = Y;
            uint16 LXPlus = Ceil(X+1, (uint32)T.BufferWidth - 1);
            uint16 LYPlus = Ceil(Y+1, (uint32)T.BufferHeight - 1);

            uint8 *TexPTR0 = ((uint8 *)T.SourceBuffer + ((uint16)T.BufferPitch * LY)     + (LX     * (uint16)T.BufferBytesPerPixel));

            uint32 *R_SrcAddress = (uint32 *)(TexPTR0 + T.BufferBits.ByteOffset * 0);
            uint32 *G_SrcAddress = (uint32 *)(TexPTR0 + T.BufferBits.ByteOffset * 1);
            uint32 *B_SrcAddress = (uint32 *)(TexPTR0 + T.BufferBits.ByteOffset * 2);
            uint32 *A_SrcAddress = (uint32 *)(TexPTR0 + T.BufferBits.ByteOffset * 3);

            real32 R_Src = (real32)(*R_SrcAddress & T.BufferBits.MaskPixel) * T.BufferBits.Normalized;

            real32 R_Col = (real32)(*R_SrcAddress & T.BufferBits.MaskPixel) * T.BufferBits.Normalized;
            real32 G_Col = (real32)(*G_SrcAddress & T.BufferBits.MaskPixel) * T.BufferBits.Normalized;
            real32 B_Col = (real32)(*B_SrcAddress & T.BufferBits.MaskPixel) * T.BufferBits.Normalized;
            real32 A_Col = (real32)(*A_SrcAddress & T.BufferBits.MaskPixel) * T.BufferBits.Normalized;

            if (A_Col == 0)
                continue;

            real32 LayerAlpha = A_Col * T.Opacity;

            uint8 *DestPixel =((uint8 *)OutputBuffer + ((uint16)Y * (uint16)T.BufferPitch) + ((uint16)X * (uint16)T.BufferBytesPerPixel));

            uint32 *R_DestAddress = (uint32 *)(DestPixel + T.BufferBits.ByteOffset * 0);
            uint32 *G_DestAddress = (uint32 *)(DestPixel + T.BufferBits.ByteOffset * 1);
            uint32 *B_DestAddress = (uint32 *)(DestPixel + T.BufferBits.ByteOffset * 2);
            uint32 *A_DestAddress = (uint32 *)(DestPixel + T.BufferBits.ByteOffset * 3);

            uint32 R_DestInt = (*R_DestAddress & T.BufferBits.MaskPixel);
            uint32 G_DestInt = (*G_DestAddress & T.BufferBits.MaskPixel);
            uint32 B_DestInt = (*B_DestAddress & T.BufferBits.MaskPixel);
            uint32 A_DestInt = (*A_DestAddress & T.BufferBits.MaskPixel);

            real32 R_Dest = (real32)(R_DestInt) * T.BufferBits.Normalized;
            real32 G_Dest = (real32)(G_DestInt) * T.BufferBits.Normalized;
            real32 B_Dest = (real32)(B_DestInt) * T.BufferBits.Normalized;
            real32 A_Dest = (real32)(A_DestInt) * T.BufferBits.Normalized;
            real32 Test = (A_Dest > 0.01) ? 1 : 0;

            real32 R_Blend = R_Col;
            real32 G_Blend = G_Col;
            real32 B_Blend = B_Col;
            real32 A_Blend = A_Col;
            // A_Blend = (A_Blend >= 0.04045) ? pow((A_Blend + 0.055) / (1 + 0.055), 2.4) : A_Blend / 12.92;

            if (LayerAlpha != 1.0f || T.BlendMode != blend_normal) {

                Fallback_Blend();

                if (A_Dest == 0) {
                    A_Blend = LayerAlpha;
                } else {
                    A_Blend = A_Dest + ((1.0f - A_Dest) * LayerAlpha);
                    real32 Alpha = pow(LayerAlpha, A_Dest);
                    R_Blend = (R_Dest * (1.0f - Alpha)) + (R_Blend * Alpha);
                    G_Blend = (G_Dest * (1.0f - Alpha)) + (G_Blend * Alpha);
                    B_Blend = (B_Dest * (1.0f - Alpha)) + (B_Blend * Alpha);
                }
            }

            uint32 R_Out = (uint32)(Normalize(R_Blend) * T.BufferBits.Bits);
            uint32 G_Out = (uint32)(Normalize(G_Blend) * T.BufferBits.Bits);
            uint32 B_Out = (uint32)(Normalize(B_Blend) * T.BufferBits.Bits);
            uint32 A_Out = (uint32)(Normalize(A_Blend) * T.BufferBits.Bits);

            if (T.SwapActive)
            {
                *R_SrcAddress = (*R_SrcAddress & ~T.BufferBits.MaskPixel) | R_DestInt;
                *G_SrcAddress = (*G_SrcAddress & ~T.BufferBits.MaskPixel) | G_DestInt;
                *B_SrcAddress = (*B_SrcAddress & ~T.BufferBits.MaskPixel) | B_DestInt;
                *A_SrcAddress = (*A_SrcAddress & ~T.BufferBits.MaskPixel) | A_DestInt;
            }
            *R_DestAddress = (*R_DestAddress & ~T.BufferBits.MaskPixel) | R_Out;
            *G_DestAddress = (*G_DestAddress & ~T.BufferBits.MaskPixel) | G_Out;
            *B_DestAddress = (*B_DestAddress & ~T.BufferBits.MaskPixel) | B_Out;
            *A_DestAddress = (*A_DestAddress & ~T.BufferBits.MaskPixel) | A_Out;
        }
    }
}

static void
Fallback_RenderLayer(transform_info T, void *OutputBuffer, rectangle RenderRegion)
{
    rectangle LayerBounds = ClipRectangle( T.ClipRect, RenderRegion);

    Assert(LayerBounds.Max.x <= T.BufferWidth);
    Assert(LayerBounds.Max.y <= T.BufferHeight);

    for (int Y = LayerBounds.Min.y; Y < LayerBounds.Max.y; Y++)
    {
        real32 StartVectorY = (real32)Y - T.OriginY;

        for (int X = LayerBounds.Min.x; X < LayerBounds.Max.x; X++)
        {
            real32 StartVectorX = X - T.OriginX;
            real32 U = (StartVectorX * T.XAxisPX) + (StartVectorY * T.XAxisPY);
            real32 V = (StartVectorX * T.YAxisPX) + (StartVectorY * T.YAxisPY);

            if (U < 1.0f && U >= 0.0f && V < 1.0f && V >= 0.0f) {

                real32 TexXFull = U * T.LayerWidth;
                uint32 TexXInt = (uint32)TexXFull;
                real32 TexX = TexXFull - TexXInt;

                real32 TexYFull = V * T.LayerHeight;
                uint32 TexYInt = (uint32)TexYFull;
                real32 TexY = TexYFull - TexYInt;

                real32 TexXInv = 1 - TexX;
                real32 TexYInv = 1 - TexY;
                real32 TexBothXInv = TexXInv * TexY;
                real32 TexBothYInv = TexX * TexYInv;
                real32 TexBoth = TexY * TexX;
                real32 TexBothInv = TexXInv * TexYInv;

                uint32 XLookup, YLookup, PixelToSeek;

                uint32 LX = TexXInt;
                uint32 LY = TexYInt;
                uint32 LXPlus = Ceil(TexXInt+1, (uint32)T.LayerWidth - 1);
                uint32 LYPlus = Ceil(TexYInt+1, (uint32)T.LayerHeight - 1);

                uint8 *TexPTR0 = ((uint8 *)T.SourceBuffer + ((uint32)T.LayerPitch * LY)     + (LX     * (uint32)T.LayerBytesPerPixel));
                uint8 *TexPTR1 = ((uint8 *)T.SourceBuffer + ((uint32)T.LayerPitch * LY)     + (LXPlus * (uint32)T.LayerBytesPerPixel));
                uint8 *TexPTR2 = ((uint8 *)T.SourceBuffer + ((uint32)T.LayerPitch * LYPlus) + (LX     * (uint32)T.LayerBytesPerPixel));
                uint8 *TexPTR3 = ((uint8 *)T.SourceBuffer + ((uint32)T.LayerPitch * LYPlus) + (LXPlus * (uint32)T.LayerBytesPerPixel));

                uint32 PixelA = *(uint32 *)TexPTR0;
                uint32 PixelB = *(uint32 *)TexPTR1;
                uint32 PixelC = *(uint32 *)TexPTR2;
                uint32 PixelD = *(uint32 *)TexPTR3;


#if 0
                real32 TexRA = (real32)(PixelA & 0xFF) * Normalized255;
                real32 TexRB = (real32)(PixelB & 0xFF) * Normalized255;
                real32 TexRC = (real32)(PixelC & 0xFF) * Normalized255;
                real32 TexRD = (real32)(PixelD & 0xFF) * Normalized255;

                real32 TexGA = (real32)((PixelA >> 8) & 0xFF) * Normalized255;
                real32 TexGB = (real32)((PixelB >> 8) & 0xFF) * Normalized255;
                real32 TexGC = (real32)((PixelC >> 8) & 0xFF) * Normalized255;
                real32 TexGD = (real32)((PixelD >> 8) & 0xFF) * Normalized255;

                real32 TexBA = (real32)((PixelA >> 16) & 0xFF) * Normalized255;
                real32 TexBB = (real32)((PixelB >> 16) & 0xFF) * Normalized255;
                real32 TexBC = (real32)((PixelC >> 16) & 0xFF) * Normalized255;
                real32 TexBD = (real32)((PixelD >> 16) & 0xFF) * Normalized255;

                real32 TexAA = (real32)((PixelA >> 24) & 0xFF) * Normalized255;
                real32 TexAB = (real32)((PixelB >> 24) & 0xFF) * Normalized255;
                real32 TexAC = (real32)((PixelC >> 24) & 0xFF) * Normalized255;
                real32 TexAD = (real32)((PixelD >> 24) & 0xFF) * Normalized255;
#else
                real32 TexRA = (real32)(*(uint32 *)(TexPTR0 + T.LayerBits.ByteOffset * 0) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;
                real32 TexGA = (real32)(*(uint32 *)(TexPTR0 + T.LayerBits.ByteOffset * 1) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;
                real32 TexBA = (real32)(*(uint32 *)(TexPTR0 + T.LayerBits.ByteOffset * 2) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;
                real32 TexAA = (real32)(*(uint32 *)(TexPTR0 + T.LayerBits.ByteOffset * 3) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;

                real32 TexRB = (real32)(*(uint32 *)(TexPTR1 + T.LayerBits.ByteOffset * 0) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;
                real32 TexGB = (real32)(*(uint32 *)(TexPTR1 + T.LayerBits.ByteOffset * 1) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;
                real32 TexBB = (real32)(*(uint32 *)(TexPTR1 + T.LayerBits.ByteOffset * 2) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;
                real32 TexAB = (real32)(*(uint32 *)(TexPTR1 + T.LayerBits.ByteOffset * 3) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;

                real32 TexRC = (real32)(*(uint32 *)(TexPTR2 + T.LayerBits.ByteOffset * 0) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;
                real32 TexGC = (real32)(*(uint32 *)(TexPTR2 + T.LayerBits.ByteOffset * 1) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;
                real32 TexBC = (real32)(*(uint32 *)(TexPTR2 + T.LayerBits.ByteOffset * 2) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;
                real32 TexAC = (real32)(*(uint32 *)(TexPTR2 + T.LayerBits.ByteOffset * 3) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;

                real32 TexRD = (real32)(*(uint32 *)(TexPTR3 + T.LayerBits.ByteOffset * 0) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;
                real32 TexGD = (real32)(*(uint32 *)(TexPTR3 + T.LayerBits.ByteOffset * 1) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;
                real32 TexBD = (real32)(*(uint32 *)(TexPTR3 + T.LayerBits.ByteOffset * 2) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;
                real32 TexAD = (real32)(*(uint32 *)(TexPTR3 + T.LayerBits.ByteOffset * 3) & T.LayerBits.MaskPixel) * T.LayerBits.Normalized;

#endif

                real32 R_Col = (TexBothInv * TexRA) + (TexBothYInv * TexRB)
                                + (TexBothXInv * TexRC) + (TexBoth * TexRD);
                real32 G_Col = (TexBothInv * TexGA) + (TexBothYInv * TexGB)
                                + (TexBothXInv * TexGC) + (TexBoth * TexGD);
                real32 B_Col = (TexBothInv * TexBA) + (TexBothYInv * TexBB)
                                + (TexBothXInv * TexBC) + (TexBoth * TexBD);
                real32 A_Col = (TexBothInv * TexAA) + (TexBothYInv * TexAB)
                                + (TexBothXInv * TexAC) + (TexBoth * TexAD);

                real32 LayerAlpha = A_Col * T.LayerOpacity;

#if DEBUG
                if (Debug.DisableAlpha == 1) {
                    A_Col = 1;
                    LayerAlpha = 1;
                }
#endif

                real32 R_Blend = R_Col;
                real32 G_Blend = G_Col;
                real32 B_Blend = B_Col;
                real32 A_Blend = A_Col;

                uint8 *DestPixel =((uint8 *)OutputBuffer + ((uint32)Y * (uint32)T.BufferPitch) + ((uint32)X * (uint32)T.BufferBytesPerPixel));
                Assert(X != (T.BufferWidth));

                uint8 *R_DestAddress = (DestPixel + T.BufferBits.ByteOffset * 0);
                uint8 *G_DestAddress = (DestPixel + T.BufferBits.ByteOffset * 1);
                uint8 *B_DestAddress = (DestPixel + T.BufferBits.ByteOffset * 2);
                uint8 *A_DestAddress = (DestPixel + T.BufferBits.ByteOffset * 3);

                if (LayerAlpha != 1.0f || T.BlendMode != blend_normal) {

                    real32 R_Dest = (real32)(*R_DestAddress & T.BufferBits.MaskPixel) * T.BufferBits.Normalized;
                    real32 G_Dest = (real32)(*G_DestAddress & T.BufferBits.MaskPixel) * T.BufferBits.Normalized;
                    real32 B_Dest = (real32)(*B_DestAddress & T.BufferBits.MaskPixel) * T.BufferBits.Normalized;
                    real32 A_Dest = (real32)(*A_DestAddress & T.BufferBits.MaskPixel) * T.BufferBits.Normalized;

                    Fallback_Blend();

                    R_Blend = (R_Dest * (1.0f - LayerAlpha)) + (R_Blend * LayerAlpha);
                    G_Blend = (G_Dest * (1.0f - LayerAlpha)) + (G_Blend * LayerAlpha);
                    B_Blend = (B_Dest * (1.0f - LayerAlpha)) + (B_Blend * LayerAlpha);

                    if (T.BlendMode == blend_normal)
                        A_Blend = A_Dest + LayerAlpha;
                        // A_Blend = A_Dest + ((1.0f - A_Dest) * LayerAlpha);
                    else
                        A_Blend = A_Dest;
#if DEBUG
                    if (Debug.DisableAlpha == 1) {
                        G_Blend = R_Blend;
                        B_Blend = R_Blend;
                    } else
                    if (Debug.DisableAlpha == 2) {
                        R_Blend = LayerAlpha;
                        G_Blend = LayerAlpha;
                        B_Blend = LayerAlpha;
                    }
#endif
                }

                uint8 R_Out = (uint8)(Normalize(R_Blend) * T.BufferBits.Bits);
                uint8 G_Out = (uint8)(Normalize(G_Blend) * T.BufferBits.Bits);
                uint8 B_Out = (uint8)(Normalize(B_Blend) * T.BufferBits.Bits);
                uint8 A_Out = (uint8)(Normalize(A_Blend) * T.BufferBits.Bits);

                *R_DestAddress =  R_Out;
                *G_DestAddress =  G_Out;
                *B_DestAddress =  B_Out;
                *A_DestAddress =  A_Out;
                // *R_DestAddress = 255;
                // *G_DestAddress = 255;
                // *B_DestAddress = 255;
                // *A_DestAddress = 255;
            }
        }
    }
}

#if 0
static void
Layer_CalcRotatedOffset(project_layer *Layer, v2 Increment, v2 Divisor, real32 *ValueX, real32 *ValueY)
{

    real32 Rad = (Layer->rotation.CurrentValue.f * (PI / 180));
    real32 s = Layer->scale.CurrentValue.f;

    v2 XAxis = V2(cos(Rad), sin(Rad)) * (Increment.x / s);
    v2 YAxis = V2(sin(Rad), -cos(Rad)) * (Increment.y / -s);

    *ValueX += XAxis.x/Divisor.x;
    *ValueY -= XAxis.y/Divisor.y;
    *ValueX -= YAxis.x/Divisor.x;
    *ValueY += YAxis.y/Divisor.y;
}

static transform_info
CalculateTransforms(project_layer *Layer, comp_buffer *CompBuffer)
{
    transform_info TransformInfo;
    source *Source = Layer->Source;

    real32 Rad = (Layer->rotation.CurrentValue.f * (PI / 180));
    real32 s = Layer->scale.CurrentValue.f;
    // v2 Scale = {Source->Raster.Width * s, Source->Raster.Height * s};

    v2 XAxis = (Source->Info.Width * s)*V2(cos(Rad), sin(Rad));
    v2 YAxis = (Source->Info.Height * -s)*V2(sin(Rad), -cos(Rad));

    real32 AnchorX = Layer->ax.CurrentValue.f;
    real32 AnchorY = Layer->ay.CurrentValue.f;

    v2 Pos = {Layer->x.CurrentValue.f, Layer->y.CurrentValue.f};
    v2 Origin = Pos - (XAxis * AnchorX) - (YAxis * AnchorY);

    real32 XLengthSq = 1.0f / LengthSq(XAxis);
    real32 YLengthSq = 1.0f / LengthSq(YAxis);

    int32 MaxX = 0;
    int32 MaxY = 0;
    int32 MinX = CompBuffer->Width;
    int32 MinY = CompBuffer->Height;

    v2 Points[4] = {Origin, Origin + XAxis, Origin + YAxis, Origin + XAxis + YAxis};
    for (int i = 0; i < 4; i++) {
        if (Points[i].x < MinX) { MinX = Points[i].x; }
        if (Points[i].y < MinY) { MinY = Points[i].y; }
        if (Points[i].x > MaxX) { MaxX = Points[i].x; }
        if (Points[i].y > MaxY) { MaxY = Points[i].y; }
    }

    TransformInfo.XAxisPX = XLengthSq*XAxis.x;
    TransformInfo.XAxisPY = XLengthSq*XAxis.y;
    TransformInfo.YAxisPX = YLengthSq*YAxis.x;
    TransformInfo.YAxisPY = YLengthSq*YAxis.y;

    uint16 Width = Source->Info.Width;
    uint16 Height = Source->Info.Height;
    uint16 WidthP, HeightP;
    Bitmap_CalcPackedDimensions(Width, Height, &WidthP, &HeightP);

    TransformInfo.LayerWidth = Width;
    TransformInfo.LayerHeight = Height;
    TransformInfo.FullLayerWidth = WidthP;
    TransformInfo.FullLayerHeight = HeightP;
    TransformInfo.LayerOpacity = Layer->opacity.CurrentValue.f;
    TransformInfo.BlendMode =Layer->BlendMode;
    TransformInfo.OriginX = Origin.x;
    TransformInfo.OriginY = Origin.y;
    TransformInfo.BufferPitch = CompBuffer->Width*CompBuffer->BytesPerPixel;
    TransformInfo.LayerPitch = Source->Info.Width*Source->Info.BytesPerPixel;
    TransformInfo.ClipRect = {MinX - (MinX & 3), MinY, MaxX + 1, MaxY + 1};

    TransformInfo.SourceBuffer = Layer->BitmapInfo.BitmapBuffer;

    return TransformInfo;
}

static void
EndRenderState(project_state *State)
{
      IsRendering = false;

      for (int16 i = 0; i < State->NumberOfLayersToRender; i++)
      {
          State->LayersToRender[i] = 0;
      }

      State->NumberOfLayersToRender = 0;
      SDL_AtomicSet(&CurrentEntry, 0);
      SDL_AtomicSet(&QueuedEntries, 0);
      SDL_AtomicSet(&CompletedEntries, 0);

}

static void
RenderLayers(render_queue *RenderInfo, rectangle RenderRegion) {
    for (int16 i = 0; i < RenderInfo->State->NumberOfLayersToRender; i++) {
        int16 Idx = RenderInfo->State->LayersToRender[i];

#if ARM
        if (InstructionMode == instruction_mode_neon)
            Fallback_RenderLayer(RenderInfo->File->Layer[Idx]->TransformInfo, RenderInfo->CompBuffer, RenderRegion);
#else
        if (InstructionMode == instruction_mode_avx)
            AVX2_RenderLayer(RenderInfo->File->Layer[Idx]->TransformInfo, RenderInfo->CompBuffer, RenderRegion);
        else if (InstructionMode == instruction_mode_sse)
            SSE2_RenderLayer(RenderInfo->File->Layer[Idx]->TransformInfo, RenderInfo->CompBuffer, RenderRegion);
#endif
        else
            Fallback_RenderLayer(RenderInfo->File->Layer[Idx]->TransformInfo, RenderInfo->CompBuffer, RenderRegion);
    }
}

static void
FinishRenderAndUpload(project_state *State, comp_buffer *CompBuffer, GLuint textureID)
{
#if PERF
    Test = __rdtsc() - Test;

    Debug.PixelCountRendered = 1280*720*5;
    printf("Cycles per pixel rendered: %li ", Test / Debug.PixelCountRendered);
    printf("Pixels rendered: %li ", Debug.PixelCountRendered);
    printf("Cycles: %li\n", Test);

    Test = 0;
    Debug.PixelCountTransparent = 0;
    Debug.PixelCountRendered = 0;
    Debug.PixelCountChecked = 0;
#endif


#if PACKEDRGB
    Bitmap_ConvertPacking(CompBuffer->PackedBuffer, CompBuffer->UnpackedBuffer,
                          CompBuffer->Width, CompBuffer->Height, CompBuffer->BytesPerPixel, 1);
#endif
    EndRenderState(State);
    glBindTexture(GL_TEXTURE_2D, textureID);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, CompBuffer->Width, CompBuffer->Height, GL_RGBA, GL_UNSIGNED_BYTE,
                    CompBuffer->UnpackedBuffer);

    // shmp->shared_framenumber = File.CurrentFrame;
    // if (sem_post(&shmp->sem2) == -1)
    //     Assert(0);
}

static void
QueueCurrentFrame(project_data *File, comp_buffer *CompBuffer, project_state *State)
{
    IsRendering = true;
    render_queue RenderInfo = {File, State, CompBuffer};

#if PERF
    Test = __rdtsc();
#endif

    for (int16 i = 0; i < File->NumberOfLayers; i++)
    {
        if (File->Layer[i]->StartFrame <= File->CurrentFrame &&
            File->Layer[i]->EndFrame >= File->CurrentFrame)
        {
            File->Layer[i]->TransformInfo = CalculateTransforms(File->Layer[i], CompBuffer);
            State->LayersToRender[State->NumberOfLayersToRender] = i;
            State->NumberOfLayersToRender++;
        }
    }


    uint16 TileWidth = CompBuffer->Width / 4;
    uint16 TileHeight = CompBuffer->Height / 4;

    for (int y = 0; y < 4; y++) {
        for (int x = 0; x < 4; x++) {
            // if (x == y) {
            rectangle RenderRegion = {TileWidth*x, TileHeight*y, TileWidth + TileWidth*x, TileHeight + TileHeight*y};
            // The render regions always have to be aligned to the top left of
            // a 4x4 chunk (at least for AVX2) and cannot exceed the bounds of
            // the comp.
            // It seems we don't need any special math to guarantee this aside
            // from dividing by 4 and modulating.
            RenderRegion.Min.x -= RenderRegion.Min.x % 4;
            RenderRegion.Min.y -= RenderRegion.Min.y % 4;
            RenderRegion.Max.x -= RenderRegion.Max.x % 4;
            RenderRegion.Max.y -= RenderRegion.Max.y % 4;
            if (RenderRegion.Max.x > CompBuffer->Width)
                RenderRegion.Max.x = CompBuffer->Width;
            if (RenderRegion.Max.y > CompBuffer->Height)
                RenderRegion.Max.y = CompBuffer->Height;
            PushRect(RenderRegion);
            // }
        }
    }


    rectangle RenderRegion = {0, 0, (int32)CompBuffer->Width, (int32)CompBuffer->Height};
    RenderLayers(&RenderInfo, RenderRegion);

}

#if ARM

static void
NEON_RenderLayer(transform_info T, comp_buffer *Buffer, rectangle RenderRegion)
{
    rectangle LayerBounds = ClipRectangle( T.ClipRect,
                                           RenderRegion );
    // Remember: since bitmaps are packed in 4x4 cubes, we always need to be aligned.
    LayerBounds.Min.x -= LayerBounds.Min.x % 4;
    LayerBounds.Min.y -= LayerBounds.Min.y % 4;

    uint16 WidthP, HeightP;
    Bitmap_CalcPackedDimensions(Buffer->Width, Buffer->Height, &WidthP, &HeightP);

    uint8 *TexPTR = (uint8 *)T.SourceBuffer;
    Assert(LayerBounds.Max.x <= Buffer->Width);
    Assert(LayerBounds.Max.y <= Buffer->Height);

    float32x4_t XAxisPX = vdupq_n_f32(T.XAxisPX);
    float32x4_t XAxisPY = vdupq_n_f32(T.XAxisPY);
    float32x4_t YAxisPX = vdupq_n_f32(T.YAxisPX);
    float32x4_t YAxisPY = vdupq_n_f32(T.YAxisPY);

    float32x4_t LayerWidth = vdupq_n_f32(T.LayerWidth);
    int32x4_t FullLayerWidth4i = vdupq_n_s32(T.FullLayerWidth*4);
    int32x4_t LayerWidthMinusOne = vdupq_n_s32(T.LayerWidth - 1);
    int32x4_t LayerHeightMinusOne = vdupq_n_s32(T.LayerHeight - 1);
    float32x4_t LayerHeight = vdupq_n_f32(T.LayerHeight);
    float32x4_t LayerOpacity = vdupq_n_f32(T.LayerOpacity);
    float32x4_t OriginX = vdupq_n_f32(T.OriginX);
    float32x4_t OriginY = vdupq_n_f32(T.OriginY);

    float32x4_t ClipPrevent = vdupq_n_f32(0.001f);
    float32x4_t One = vdupq_n_f32(1);
    float32x4_t Two = vdupq_n_f32(2);
    float32x4_t Zero = vdupq_n_f32(0);

    float32x4_t ZeroPoint25 = vdupq_n_f32(0.25);
    float32x4_t ZeroPointFive = vdupq_n_f32(0.5);
    int32x4_t Onei = vdupq_n_s32(1);
    float32x4_t Four = vdupq_n_f32(4);
    int32x4_t FF = vdupq_n_s32(0xFF);
    int32x4_t BottomTwoBits = vdupq_n_s32(0x03);
    int32x4_t Fouri = vdupq_n_s32(4);
    int32x4_t Sixteeni = vdupq_n_s32(16);
    float32x4_t Real255 = vdupq_n_f32(255.0f);
    float32x4_t Norm255 = vdupq_n_f32(1/255.0f);

    // NOTE(fox): Each loop operates on 4 pixels, 4 horizontal by 1 vertical.

    // TODO(fox): A possible optimization could be made by using the 32x4x4
    // load intrinsic and a loop that repeats four times.

    for (int32 Y = LayerBounds.Min.y; Y < LayerBounds.Max.y; Y++)
    {
        real32 xvals[4] = { (real32)LayerBounds.Min.x, (real32)LayerBounds.Min.x+1,
                            (real32)LayerBounds.Min.x+2, (real32)LayerBounds.Min.x+3 };
        float32x4_t PixelX = vld1q_f32(xvals);

        float32x4_t PixelY = vdupq_n_f32((real32)Y);
        float32x4_t StartVectorY = vsubq_f32(PixelY, OriginY);

        for (int32 X = LayerBounds.Min.x; X < LayerBounds.Max.x; X += 4)
        {

            float32x4_t StartVectorX = vsubq_f32(PixelX, OriginX);

            uint32 XLookup = (X >> 2)*16 + (X % 4);
            uint32 YLookup = (Y >> 2)*(WidthP*4) + (Y % 4)*4;
            uint32 PixelToSeek = XLookup + YLookup;
            uint8 *Pixel = (uint8 *)Buffer->PackedBuffer + PixelToSeek*Buffer->BytesPerPixel;

            float32x4_t U = vaddq_f32(vmulq_f32(StartVectorX, XAxisPX), vmulq_f32(StartVectorY, XAxisPY));
            float32x4_t V = vaddq_f32(vmulq_f32(StartVectorX, YAxisPX), vmulq_f32(StartVectorY, YAxisPY));

            uint32x4_t LayerMask = vandq_u32(vandq_u32(vcgeq_f32(U, Zero), vcltq_f32(U, One)),
                                             vandq_u32(vcgeq_f32(V, Zero), vcltq_f32(V, One)));

            // TODO(fox): Make more efficient with some sort of truncation
            uint32 comp[4];
            vst1q_u32(comp, LayerMask);
            if (comp[0] || comp[1] || comp[2] || comp[3]) {
                U = vmaxq_f32(vminq_f32(One, U), Zero);
                V = vmaxq_f32(vminq_f32(One, V), Zero);

                float32x4_t TexXFull = vmulq_f32(U, LayerWidth);
                float32x4_t TexYFull = vmulq_f32(V, LayerHeight);
                int32x4_t TexXInt = vcvtq_s32_f32(TexXFull);
                int32x4_t TexXIntPlusOne = vaddq_f32(TexXInt, vandq_u32(vcltq_u32(TexXInt, LayerWidthMinusOne), Onei));
                int32x4_t TexYInt = vcvtq_s32_f32(TexYFull);
                int32x4_t TexYIntPlusOne = vaddq_f32(TexYInt, vandq_u32(vcltq_u32(TexYInt, LayerWidthMinusOne), Onei));

                float32x4_t TexX = vsubq_f32(TexXFull, vcvtq_f32_u32(TexXInt));
                float32x4_t TexY = vsubq_f32(TexYFull, vcvtq_f32_u32(TexYInt));
                float32x4_t TexXInv     = vsubq_f32(One, TexX);
                float32x4_t TexYInv     = vsubq_f32(One, TexY);
                float32x4_t TexBothXInv = vmulq_f32(TexXInv, TexY);
                float32x4_t TexBothYInv = vmulq_f32(TexX, TexYInv);
                float32x4_t TexBoth     = vmulq_f32(TexY, TexX);
                float32x4_t TexBothInv  = vmulq_f32(TexXInv, TexYInv);

                int32x4_t XLookup =        vaddq_u32(vmulq_u32(vshrq_n_u32(TexXInt, 2), Sixteeni),
                                                    vandq_u32(TexXInt, BottomTwoBits));
                int32x4_t YLookup =        vaddq_u32(vmulq_u32(vshrq_n_u32(TexYInt, 2), FullLayerWidth4i),
                                                    vmulq_u32(vandq_u32(TexYInt, BottomTwoBits), Fouri));
                int32x4_t XLookupPlusOne = vaddq_u32(vmulq_u32(vshrq_n_u32(TexXIntPlusOne, 2), Sixteeni),
                                                    vandq_u32(TexXIntPlusOne, BottomTwoBits));
                int32x4_t YLookupPlusOne = vaddq_u32(vmulq_u32(vshrq_n_u32(TexYIntPlusOne, 2), FullLayerWidth4i),
                                                    vmulq_u32(vandq_u32(TexYIntPlusOne, BottomTwoBits), Fouri));

                int32x4_t PixelLookupTL = vaddq_u32(XLookup, YLookup);
                int32x4_t PixelLookupTR = vaddq_u32(XLookupPlusOne, YLookup);
                int32x4_t PixelLookupBL = vaddq_u32(XLookup, YLookupPlusOne);
                int32x4_t PixelLookupBR = vaddq_u32(XLookupPlusOne, YLookupPlusOne);

                // I thought NEON had gather/scatter, but it appears it doesn't...
            }

        PixelX = vaddq_f32(PixelX, Four);
        }
    }
}

#else

#if 0
#include "iacaMarks.h"
#else
#define IACA_START
#define IACA_END
#endif

static void
AVX2_RenderLayer(transform_info T, comp_buffer *Buffer, rectangle RenderRegion)
{
    rectangle LayerBounds = ClipRectangle( T.ClipRect,
                                           RenderRegion );
    // Remember: since bitmaps are packed in 4x4 cubes, we always need to be aligned.
    LayerBounds.Min.x -= LayerBounds.Min.x % 4;
    LayerBounds.Min.y -= LayerBounds.Min.y % 4;

    uint16 WidthP, HeightP;
    Bitmap_CalcPackedDimensions(Buffer->Width, Buffer->Height, &WidthP, &HeightP);

    uint8 *TexPTR = (uint8 *)T.SourceBuffer;
    Assert(LayerBounds.Max.x <= Buffer->Width);
    Assert(LayerBounds.Max.y <= Buffer->Height);

    __m256 XAxisPX = _mm256_set1_ps(T.XAxisPX);
    __m256 XAxisPY = _mm256_set1_ps(T.XAxisPY);
    __m256 YAxisPX = _mm256_set1_ps(T.YAxisPX);
    __m256 YAxisPY = _mm256_set1_ps(T.YAxisPY);

    __m256 LayerWidth = _mm256_set1_ps(T.LayerWidth);
    __m256 LayerBoundsMaxX = _mm256_set1_ps(LayerBounds.Max.x);
    __m256i FullLayerWidth4i = _mm256_set1_epi32(T.FullLayerWidth*4);
    __m256i LayerWidthMinusOne = _mm256_set1_epi32(T.LayerWidth - 1);
    __m256i LayerHeightMinusOne = _mm256_set1_epi32(T.LayerHeight - 1);
    __m256 LayerHeight = _mm256_set1_ps(T.LayerHeight);
    __m256 LayerOpacity = _mm256_set1_ps(T.LayerOpacity);
    __m256 OriginX = _mm256_set1_ps(T.OriginX);
    __m256 OriginY = _mm256_set1_ps(T.OriginY);

    __m256 ClipPrevent = _mm256_set1_ps(0.001f);
    __m256 One = _mm256_set1_ps(1);
    __m256 Two = _mm256_set1_ps(2);
    __m256 Zero = _mm256_set1_ps(0);

    __m256 ZeroPoint25 = _mm256_set1_ps(0.25);
    __m256 ZeroPointFive = _mm256_set1_ps(0.5);
    __m256i Onei = _mm256_set1_epi32(1);
    __m256 Four = _mm256_set1_ps(4);
    __m256 Eight = _mm256_set1_ps(8);
    __m256i FF = _mm256_set1_epi32(0xFF);
    __m256i BottomTwoBits = _mm256_set1_epi32(0x03);
    __m256i Fouri = _mm256_set1_epi32(4);
    __m256i Sixteeni = _mm256_set1_epi32(16);
    __m256 Real255 = _mm256_set1_ps(255.0f);
    __m256 Norm255 = _mm256_set1_ps(1/255.0f);
    // __m256i White = _mm256_setr_epi32(0xFFFFFFFF, 0, 0, 0, 0xFFFFFFFF, 0, 0, 0);
    // __m256i White2 = _mm256_set1_epi32(0xFFFFFFFF);

    // TODO(fox): Tried an MSAA technique for anti aliasing, but it still looks pretty sucky.
    __m256 X0 = _mm256_set1_ps(0.30);
    __m256 Y0 = _mm256_set1_ps(0.10);
    __m256 X1 = _mm256_set1_ps(0.80);
    __m256 Y1 = _mm256_set1_ps(0.35);
    __m256 X2 = _mm256_set1_ps(0.05);
    __m256 Y2 = _mm256_set1_ps(0.60);
    __m256 X3 = _mm256_set1_ps(0.55);
    __m256 Y3 = _mm256_set1_ps(0.85);


#if PACKEDRGB
#else
    __m256i LayerPitch = _mm256_set1_epi32(T.LayerPitch);
    __m256i BytesPerPixel = _mm256_set1_epi32(Buffer->BytesPerPixel);
#endif

#if PACKEDRGB
    for (int32 Y = LayerBounds.Min.y; Y < LayerBounds.Max.y; Y+=2)
    {
        __m256 PixelX = _mm256_setr_ps((real32)LayerBounds.Min.x,
                                       (real32)LayerBounds.Min.x+1,
                                       (real32)LayerBounds.Min.x+2,
                                       (real32)LayerBounds.Min.x+3,
                                       (real32)LayerBounds.Min.x,
                                       (real32)LayerBounds.Min.x+1,
                                       (real32)LayerBounds.Min.x+2,
                                       (real32)LayerBounds.Min.x+3);

        __m256 PixelY = _mm256_setr_ps((real32)Y,
                                       (real32)Y,
                                       (real32)Y,
                                       (real32)Y,
                                       (real32)Y+1,
                                       (real32)Y+1,
                                       (real32)Y+1,
                                       (real32)Y+1);
#else
    for (int32 Y = LayerBounds.Min.y; Y < LayerBounds.Max.y; Y++)
    {
        __m256 PixelX = _mm256_setr_ps((real32)LayerBounds.Min.x,
                                       (real32)LayerBounds.Min.x+1,
                                       (real32)LayerBounds.Min.x+2,
                                       (real32)LayerBounds.Min.x+3,
                                       (real32)LayerBounds.Min.x+4,
                                       (real32)LayerBounds.Min.x+5,
                                       (real32)LayerBounds.Min.x+6,
                                       (real32)LayerBounds.Min.x+7);

        __m256 PixelY = _mm256_set1_ps((real32)Y);
#endif

        __m256 StartVectorY = _mm256_sub_ps(PixelY, OriginY);

#if PACKEDRGB
        for (int32 X = LayerBounds.Min.x; X < LayerBounds.Max.x; X += 4)
#else
        for (int32 X = LayerBounds.Min.x; X < LayerBounds.Max.x; X += 8)
#endif
        {

            IACA_START;

            __m256 StartVectorX = _mm256_sub_ps(PixelX, OriginX);
            __m256 StartVectorX0 = _mm256_add_ps(StartVectorX, X0);
            __m256 StartVectorY0 = _mm256_add_ps(StartVectorY, Y0);
            __m256 StartVectorX1 = _mm256_add_ps(StartVectorX, X1);
            __m256 StartVectorY1 = _mm256_add_ps(StartVectorY, Y1);
            __m256 StartVectorX2 = _mm256_add_ps(StartVectorX, X2);
            __m256 StartVectorY2 = _mm256_add_ps(StartVectorY, Y2);
            __m256 StartVectorX3 = _mm256_add_ps(StartVectorX, X3);
            __m256 StartVectorY3 = _mm256_add_ps(StartVectorY, Y3);

#if PACKEDRGB
            uint32 XLookup = (X >> 2)*16 + (X % 4);
            uint32 YLookup = (Y >> 2)*(WidthP*4) + (Y % 4)*4;
            uint32 PixelToSeek = XLookup + YLookup;
            uint8 *Pixel = (uint8 *)Buffer->PackedBuffer + PixelToSeek*Buffer->BytesPerPixel;
#else
            uint8 *Pixel = (uint8 *)Buffer->UnpackedBuffer + Y*T.BufferPitch + X*Buffer->BytesPerPixel;
#endif

            __m256 U = _mm256_add_ps(_mm256_mul_ps(StartVectorX, XAxisPX), _mm256_mul_ps(StartVectorY, XAxisPY));
            __m256 V = _mm256_add_ps(_mm256_mul_ps(StartVectorX, YAxisPX), _mm256_mul_ps(StartVectorY, YAxisPY));

            __m256 U0 = _mm256_add_ps(_mm256_mul_ps(StartVectorX0, XAxisPX), _mm256_mul_ps(StartVectorY0, XAxisPY));
            __m256 V0 = _mm256_add_ps(_mm256_mul_ps(StartVectorX0, YAxisPX), _mm256_mul_ps(StartVectorY0, YAxisPY));
            __m256 U1 = _mm256_add_ps(_mm256_mul_ps(StartVectorX1, XAxisPX), _mm256_mul_ps(StartVectorY1, XAxisPY));
            __m256 V1 = _mm256_add_ps(_mm256_mul_ps(StartVectorX1, YAxisPX), _mm256_mul_ps(StartVectorY1, YAxisPY));
            __m256 U2 = _mm256_add_ps(_mm256_mul_ps(StartVectorX2, XAxisPX), _mm256_mul_ps(StartVectorY2, XAxisPY));
            __m256 V2 = _mm256_add_ps(_mm256_mul_ps(StartVectorX2, YAxisPX), _mm256_mul_ps(StartVectorY2, YAxisPY));
            __m256 U3 = _mm256_add_ps(_mm256_mul_ps(StartVectorX3, XAxisPX), _mm256_mul_ps(StartVectorY3, XAxisPY));
            __m256 V3 = _mm256_add_ps(_mm256_mul_ps(StartVectorX3, YAxisPX), _mm256_mul_ps(StartVectorY3, YAxisPY));

            __m256 LayerMask0 = _mm256_and_ps(_mm256_and_ps(_mm256_cmp_ps(U0, Zero, 13), _mm256_cmp_ps(U0, One, 1)),
                                              _mm256_and_ps(_mm256_cmp_ps(V0, Zero, 13), _mm256_cmp_ps(V0, One, 1)));
            __m256 LayerMask1 = _mm256_and_ps(_mm256_and_ps(_mm256_cmp_ps(U1, Zero, 13), _mm256_cmp_ps(U1, One, 1)),
                                              _mm256_and_ps(_mm256_cmp_ps(V1, Zero, 13), _mm256_cmp_ps(V1, One, 1)));
            __m256 LayerMask2 = _mm256_and_ps(_mm256_and_ps(_mm256_cmp_ps(U2, Zero, 13), _mm256_cmp_ps(U2, One, 1)),
                                              _mm256_and_ps(_mm256_cmp_ps(V2, Zero, 13), _mm256_cmp_ps(V2, One, 1)));
            __m256 LayerMask3 = _mm256_and_ps(_mm256_and_ps(_mm256_cmp_ps(U3, Zero, 13), _mm256_cmp_ps(U3, One, 1)),
                                              _mm256_and_ps(_mm256_cmp_ps(V3, Zero, 13), _mm256_cmp_ps(V3, One, 1)));

            // Each point that passes adds .25
            __m256 Avg = _mm256_add_ps(_mm256_add_ps(_mm256_and_ps(LayerMask0, ZeroPoint25), _mm256_and_ps(LayerMask1, ZeroPoint25)),
                                       _mm256_add_ps(_mm256_and_ps(LayerMask2, ZeroPoint25), _mm256_and_ps(LayerMask3, ZeroPoint25)));

            // Preventing overlap between threads for non-packed. One nice thing
            // about packed is that the 4-padded bitmap means we can set up the
            // boundaries so we don't have to check this ever.
            __m256i TileBarrier = _mm256_cvtps_epi32(_mm256_cmp_ps(PixelX, LayerBoundsMaxX, 13));

            // Zero - no points pass
            // One - all points pass; not an edge
            __m256i Mask = _mm256_cvtps_epi32(_mm256_cmp_ps(Avg, Zero, 14));
            __m256i NonEdge = _mm256_cvtps_epi32(_mm256_cmp_ps(Avg, One, 13));
            __m256i TotalMask = _mm256_andnot_si256(TileBarrier, _mm256_and_si256(Mask, NonEdge));

            // __m256 LayerMask = _mm256_and_ps(_mm256_and_ps(_mm256_cmp_ps(U, Zero, 13), _mm256_cmp_ps(U, One, 1)),
            //                                  _mm256_and_ps(_mm256_cmp_ps(V, Zero, 13), _mm256_cmp_ps(V, One, 1)));

            // If all of the pixels are zeroed in the mask (aka fall outside
            // the UV lookup), we can skip the iteration.
            if (_mm256_movemask_epi8(TotalMask))
            {
                __m256i EdgeMask = _mm256_andnot_si256(NonEdge, Mask);

                U = _mm256_max_ps(_mm256_min_ps(One, U), Zero);
                V = _mm256_max_ps(_mm256_min_ps(One, V), Zero);

                __m256 TexXFull = _mm256_mul_ps(U, LayerWidth);
                __m256 TexYFull = _mm256_mul_ps(V, LayerHeight);
                __m256i TexXInt = _mm256_cvttps_epi32(TexXFull);
                __m256i TexYInt = _mm256_cvttps_epi32(TexYFull);
                __m256i TexXIntPlusOne = _mm256_add_epi32(TexXInt, _mm256_and_si256(_mm256_cmpgt_epi32(LayerWidthMinusOne, TexXInt), Onei));
                __m256i TexYIntPlusOne = _mm256_add_epi32(TexYInt, _mm256_and_si256(_mm256_cmpgt_epi32(LayerHeightMinusOne, TexYInt), Onei));
                // NOTE(fox): The comparison is for when we're on the last pixel of the texel.

                __m256 TexX = _mm256_sub_ps(TexXFull, _mm256_cvtepi32_ps(TexXInt));
                __m256 TexY = _mm256_sub_ps(TexYFull, _mm256_cvtepi32_ps(TexYInt));
                __m256 TexXInv     = _mm256_sub_ps(One, TexX);
                __m256 TexYInv     = _mm256_sub_ps(One, TexY);
                __m256 TexBothXInv = _mm256_mul_ps(TexXInv, TexY);
                __m256 TexBothYInv = _mm256_mul_ps(TexX, TexYInv);
                __m256 TexBoth     = _mm256_mul_ps(TexY, TexX);
                __m256 TexBothInv  = _mm256_mul_ps(TexXInv, TexYInv);

#if PACKEDRGB
                __m256i XLookup =        _mm256_add_epi32(_mm256_mullo_epi32(_mm256_srli_epi32(TexXInt, 2), Sixteeni),
                                                          _mm256_and_si256(TexXInt, BottomTwoBits));
                __m256i YLookup =        _mm256_add_epi32(_mm256_mullo_epi32(_mm256_srli_epi32(TexYInt, 2), FullLayerWidth4i),
                                                          _mm256_mullo_epi32(_mm256_and_si256(TexYInt, BottomTwoBits), Fouri));
                __m256i XLookupPlusOne = _mm256_add_epi32(_mm256_mullo_epi32(_mm256_srli_epi32(TexXIntPlusOne, 2), Sixteeni),
                                                          _mm256_and_si256(TexXIntPlusOne, BottomTwoBits));
                __m256i YLookupPlusOne = _mm256_add_epi32(_mm256_mullo_epi32(_mm256_srli_epi32(TexYIntPlusOne, 2), FullLayerWidth4i),
                                                          _mm256_mullo_epi32(_mm256_and_si256(TexYIntPlusOne, BottomTwoBits), Fouri));
#else
                __m256i XLookup = TexXInt;
                __m256i YLookup = _mm256_cvtps_epi32(_mm256_mul_ps(_mm256_cvtepi32_ps(TexYInt), LayerWidth));
                __m256i XLookupPlusOne = TexXIntPlusOne;
                __m256i YLookupPlusOne = _mm256_cvtps_epi32(_mm256_mul_ps(_mm256_cvtepi32_ps(TexYIntPlusOne), LayerWidth));
#endif

                __m256i PixelLookupTL = _mm256_add_epi32(XLookup, YLookup);
                __m256i PixelLookupTR = _mm256_add_epi32(XLookupPlusOne, YLookup);
                __m256i PixelLookupBL = _mm256_add_epi32(XLookup, YLookupPlusOne);
                __m256i PixelLookupBR = _mm256_add_epi32(XLookupPlusOne, YLookupPlusOne);

                // The big feature of AVX2: gathering.
                __m256i PixelsTL = _mm256_i32gather_epi32((const int32 *)TexPTR, PixelLookupTL, 4);
                __m256i PixelsTR = _mm256_i32gather_epi32((const int32 *)TexPTR, PixelLookupTR, 4);
                __m256i PixelsBL = _mm256_i32gather_epi32((const int32 *)TexPTR, PixelLookupBL, 4);
                __m256i PixelsBR = _mm256_i32gather_epi32((const int32 *)TexPTR, PixelLookupBR, 4);

                __m256 R_TexTL = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(                  PixelsTL,      FF)), Norm255);
                __m256 G_TexTL = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_srli_epi32(PixelsTL, 8),  FF)), Norm255);
                __m256 B_TexTL = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_srli_epi32(PixelsTL, 16), FF)), Norm255);
                __m256 A_TexTL = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_srli_epi32(PixelsTL, 24), FF)), Norm255);

                __m256 R_TexTR = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(                  PixelsTR,      FF)), Norm255);
                __m256 G_TexTR = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_srli_epi32(PixelsTR, 8),  FF)), Norm255);
                __m256 B_TexTR = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_srli_epi32(PixelsTR, 16), FF)), Norm255);
                __m256 A_TexTR = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_srli_epi32(PixelsTR, 24), FF)), Norm255);

                __m256 R_TexBL = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(                  PixelsBL,      FF)), Norm255);
                __m256 G_TexBL = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_srli_epi32(PixelsBL, 8),  FF)), Norm255);
                __m256 B_TexBL = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_srli_epi32(PixelsBL, 16), FF)), Norm255);
                __m256 A_TexBL = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_srli_epi32(PixelsBL, 24), FF)), Norm255);

                __m256 R_TexBR = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(                  PixelsBR,      FF)), Norm255);
                __m256 G_TexBR = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_srli_epi32(PixelsBR, 8),  FF)), Norm255);
                __m256 B_TexBR = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_srli_epi32(PixelsBR, 16), FF)), Norm255);
                __m256 A_TexBR = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_srli_epi32(PixelsBR, 24), FF)), Norm255);

                __m256 R_Col = _mm256_add_ps(_mm256_add_ps(_mm256_mul_ps(TexBothInv,  R_TexTL),
                                                           _mm256_mul_ps(TexBothYInv, R_TexTR)),
                                             _mm256_add_ps(_mm256_mul_ps(TexBothXInv, R_TexBL),
                                                           _mm256_mul_ps(TexBoth,     R_TexBR)));
                __m256 G_Col = _mm256_add_ps(_mm256_add_ps(_mm256_mul_ps(TexBothInv,  G_TexTL),
                                                           _mm256_mul_ps(TexBothYInv, G_TexTR)),
                                             _mm256_add_ps(_mm256_mul_ps(TexBothXInv, G_TexBL),
                                                           _mm256_mul_ps(TexBoth,     G_TexBR)));
                __m256 B_Col = _mm256_add_ps(_mm256_add_ps(_mm256_mul_ps(TexBothInv,  B_TexTL),
                                                           _mm256_mul_ps(TexBothYInv, B_TexTR)),
                                             _mm256_add_ps(_mm256_mul_ps(TexBothXInv, B_TexBL),
                                                           _mm256_mul_ps(TexBoth,     B_TexBR)));
                __m256 A_Col = _mm256_add_ps(_mm256_add_ps(_mm256_mul_ps(TexBothInv,  A_TexTL),
                                                           _mm256_mul_ps(TexBothYInv, A_TexTR)),
                                             _mm256_add_ps(_mm256_mul_ps(TexBothXInv, A_TexBL),
                                                           _mm256_mul_ps(TexBoth,     A_TexBR)));

                // Apply anti-aliasing to edges if there are any
                if (_mm256_movemask_epi8(EdgeMask))
                {
                    A_Col = _mm256_blendv_ps(A_Col, _mm256_mul_ps(A_Col, Avg), _mm256_cvtepi32_ps(EdgeMask));
                }

        IACA_END;
                __m256 LayerAlpha = _mm256_mul_ps(A_Col, LayerOpacity);
                __m256 LayerAlphaInv = _mm256_sub_ps(One, LayerAlpha);

                // Hoisted out of some blend modes; maybe it'd be better to just keep them in there.
                __m256 R_Colx2  = _mm256_mul_ps(R_Col, Two);
                __m256 R_ColInv = _mm256_sub_ps(One, R_Col);

                __m256 G_Colx2  = _mm256_mul_ps(G_Col, Two);
                __m256 G_ColInv = _mm256_sub_ps(One, G_Col);

                __m256 B_Colx2  = _mm256_mul_ps(B_Col, Two);
                __m256 B_ColInv = _mm256_sub_ps(One, B_Col);

                __m256 R_Blend = R_Col;
                __m256 G_Blend = G_Col;
                __m256 B_Blend = B_Col;
                __m256 A_Blend = LayerAlpha;

                // Only load the dest pixel if we actually need to (a pixel's opacity isn't 255 or the blend mode requires it).
                if (T.BlendMode != blend_normal || _mm256_movemask_epi8(_mm256_cvtps_epi32(_mm256_cmp_ps(LayerAlpha, One, 2))))
                {
                    __m256i DestPixel = _mm256_loadu_si256((const __m256i *)Pixel);
                    __m256 R_Dest = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(                  DestPixel,      FF)), Norm255);
                    __m256 G_Dest = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_srli_epi32(DestPixel, 8),  FF)), Norm255);
                    __m256 B_Dest = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_srli_epi32(DestPixel, 16), FF)), Norm255);
                    __m256 A_Dest = _mm256_mul_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_srli_epi32(DestPixel, 24), FF)), Norm255);

                    switch (T.BlendMode)
                    {
                        case blend_normal:
                        {
                        } break;
                        case blend_multiply:
                        {
                            R_Blend  = _mm256_mul_ps(R_Dest, R_Col);
                            G_Blend  = _mm256_mul_ps(G_Dest, G_Col);
                            B_Blend  = _mm256_mul_ps(B_Dest, B_Col);
                        } break;
                        case blend_colorburn:
                        {
                            // NOTE(fox): A small amount is added to Col since images with zero for alpha may also zero out the
                            // color channels, causing black clipping.
                            R_Blend  = _mm256_sub_ps(One, _mm256_div_ps(_mm256_sub_ps(One, R_Dest), _mm256_add_ps(R_Col, ClipPrevent)));
                            G_Blend  = _mm256_sub_ps(One, _mm256_div_ps(_mm256_sub_ps(One, G_Dest), _mm256_add_ps(G_Col, ClipPrevent)));
                            B_Blend  = _mm256_sub_ps(One, _mm256_div_ps(_mm256_sub_ps(One, B_Dest), _mm256_add_ps(B_Col, ClipPrevent)));
                        } break;
                        case blend_linearburn:
                        {
                            R_Blend  = _mm256_sub_ps(_mm256_add_ps(R_Dest, R_Col), One);
                            G_Blend  = _mm256_sub_ps(_mm256_add_ps(G_Dest, G_Col), One);
                            B_Blend  = _mm256_sub_ps(_mm256_add_ps(B_Dest, B_Col), One);
                        } break;
                        case blend_add:
                        {
                            R_Blend  = _mm256_add_ps(R_Dest, R_Col);
                            G_Blend  = _mm256_add_ps(G_Dest, G_Col);
                            B_Blend  = _mm256_add_ps(B_Dest, B_Col);
                        } break;
                        case blend_screen:
                        {
                            R_Blend  = _mm256_sub_ps(One, _mm256_mul_ps(_mm256_sub_ps(One, R_Dest), R_ColInv));
                            G_Blend  = _mm256_sub_ps(One, _mm256_mul_ps(_mm256_sub_ps(One, G_Dest), G_ColInv));
                            B_Blend  = _mm256_sub_ps(One, _mm256_mul_ps(_mm256_sub_ps(One, B_Dest), B_ColInv));
                        } break;
                        case blend_overlay:
                        {
                            __m256 R_Mask  = _mm256_cmp_ps(R_Dest,  ZeroPointFive, 1);
                            __m256 G_Mask  = _mm256_cmp_ps(G_Dest,  ZeroPointFive, 1);
                            __m256 B_Mask  = _mm256_cmp_ps(B_Dest,  ZeroPointFive, 1);
                            __m256 R_Lower = _mm256_mul_ps(Two, _mm256_mul_ps(R_Dest, R_Col));
                            __m256 G_Lower = _mm256_mul_ps(Two, _mm256_mul_ps(G_Dest, G_Col));
                            __m256 B_Lower = _mm256_mul_ps(Two, _mm256_mul_ps(B_Dest, B_Col));
                            __m256 R_Upper = _mm256_sub_ps(One, _mm256_mul_ps(Two, _mm256_mul_ps(_mm256_sub_ps(One, R_Dest),  R_ColInv)));
                            __m256 G_Upper = _mm256_sub_ps(One, _mm256_mul_ps(Two, _mm256_mul_ps(_mm256_sub_ps(One, G_Dest),  G_ColInv)));
                            __m256 B_Upper = _mm256_sub_ps(One, _mm256_mul_ps(Two, _mm256_mul_ps(_mm256_sub_ps(One, B_Dest),  B_ColInv)));
                            R_Blend = _mm256_blendv_ps(R_Upper, R_Lower, R_Mask);
                            G_Blend = _mm256_blendv_ps(G_Upper, G_Lower, G_Mask);
                            B_Blend = _mm256_blendv_ps(B_Upper, B_Lower, B_Mask);
                        } break;
                        case blend_softlight:
                        {
                            // using Pegtop's equation
                            R_Blend  = _mm256_add_ps(_mm256_mul_ps(_mm256_sub_ps(One, R_Colx2), _mm256_mul_ps(R_Dest, R_Dest)), _mm256_mul_ps(R_Colx2, R_Dest));
                            G_Blend  = _mm256_add_ps(_mm256_mul_ps(_mm256_sub_ps(One, G_Colx2), _mm256_mul_ps(G_Dest, G_Dest)), _mm256_mul_ps(G_Colx2, G_Dest));
                            B_Blend  = _mm256_add_ps(_mm256_mul_ps(_mm256_sub_ps(One, B_Colx2), _mm256_mul_ps(B_Dest, B_Dest)), _mm256_mul_ps(B_Colx2, B_Dest));
                        } break;
                        case blend_hardlight:
                        {
                            __m256 R_Mask   = _mm256_cmp_ps(R_Dest,  ZeroPointFive, 13);
                            __m256 G_Mask   = _mm256_cmp_ps(G_Dest,  ZeroPointFive, 13);
                            __m256 B_Mask   = _mm256_cmp_ps(B_Dest,  ZeroPointFive, 13);
                            __m256 R_Lower  = _mm256_mul_ps(Two, _mm256_mul_ps(R_Dest, R_Col));
                            __m256 G_Lower  = _mm256_mul_ps(Two, _mm256_mul_ps(G_Dest, G_Col));
                            __m256 B_Lower  = _mm256_mul_ps(Two, _mm256_mul_ps(B_Dest, B_Col));
                            __m256 R_Upper  = _mm256_sub_ps(One, _mm256_mul_ps(Two, _mm256_mul_ps(_mm256_sub_ps(One, R_Dest),  R_ColInv)));
                            __m256 G_Upper  = _mm256_sub_ps(One, _mm256_mul_ps(Two, _mm256_mul_ps(_mm256_sub_ps(One, G_Dest),  G_ColInv)));
                            __m256 B_Upper  = _mm256_sub_ps(One, _mm256_mul_ps(Two, _mm256_mul_ps(_mm256_sub_ps(One, B_Dest),  B_ColInv)));
                            R_Blend = _mm256_blendv_ps(R_Upper, R_Lower, R_Mask);
                            G_Blend = _mm256_blendv_ps(G_Upper, G_Lower, G_Mask);
                            B_Blend = _mm256_blendv_ps(B_Upper, B_Lower, B_Mask);
                        } break;
                        case blend_subtract:
                        {
                            R_Blend  = _mm256_sub_ps(R_Dest, R_Col);
                            G_Blend  = _mm256_sub_ps(G_Dest, G_Col);
                            B_Blend  = _mm256_sub_ps(B_Dest, B_Col);
                        } break;
                        case blend_divide:
                        {
                            R_Blend  = _mm256_div_ps(R_Dest, _mm256_add_ps(R_Col, ClipPrevent));
                            G_Blend  = _mm256_div_ps(G_Dest, _mm256_add_ps(G_Col, ClipPrevent));
                            B_Blend  = _mm256_div_ps(B_Dest, _mm256_add_ps(B_Col, ClipPrevent));
                        } break;
                        case blend_difference:
                        {
                            __m256 R_Lower  = _mm256_sub_ps(R_Col, R_Dest);
                            __m256 G_Lower  = _mm256_sub_ps(G_Col, G_Dest);
                            __m256 B_Lower  = _mm256_sub_ps(B_Col, B_Dest);
                            __m256 R_Upper  = _mm256_sub_ps(R_Dest, R_Col);
                            __m256 G_Upper  = _mm256_sub_ps(G_Dest, G_Col);
                            __m256 B_Upper  = _mm256_sub_ps(B_Dest, B_Col);
                            __m256 R_Mask  = _mm256_cmp_ps(R_Lower,  Zero, 14);
                            __m256 G_Mask  = _mm256_cmp_ps(G_Lower,  Zero, 14);
                            __m256 B_Mask  = _mm256_cmp_ps(B_Lower,  Zero, 14);
                            R_Blend = _mm256_blendv_ps(R_Upper, R_Lower, R_Mask);
                            G_Blend = _mm256_blendv_ps(G_Upper, G_Lower, G_Mask);
                            B_Blend = _mm256_blendv_ps(B_Upper, B_Lower, B_Mask);
                        } break;
                    }

                    R_Blend = _mm256_add_ps(_mm256_mul_ps(R_Dest, LayerAlphaInv), _mm256_mul_ps(R_Blend, LayerAlpha));
                    G_Blend = _mm256_add_ps(_mm256_mul_ps(G_Dest, LayerAlphaInv), _mm256_mul_ps(G_Blend, LayerAlpha));
                    B_Blend = _mm256_add_ps(_mm256_mul_ps(B_Dest, LayerAlphaInv), _mm256_mul_ps(B_Blend, LayerAlpha));

                    // Standard behavior in photo apps is for blend modes to
                    // inherit underlying opacity instead of adding to it.
                    if (T.BlendMode == blend_normal)
                        A_Blend = _mm256_add_ps(A_Dest, LayerAlpha);
                    else
                        A_Blend = A_Dest;
                }

                __m256i R_Out = _mm256_cvtps_epi32(_mm256_mul_ps(_mm256_max_ps(_mm256_min_ps(One, R_Blend), Zero), Real255));
                __m256i G_Out = _mm256_cvtps_epi32(_mm256_mul_ps(_mm256_max_ps(_mm256_min_ps(One, G_Blend), Zero), Real255));
                __m256i B_Out = _mm256_cvtps_epi32(_mm256_mul_ps(_mm256_max_ps(_mm256_min_ps(One, B_Blend), Zero), Real255));
                __m256i A_Out = _mm256_cvtps_epi32(_mm256_mul_ps(_mm256_max_ps(_mm256_min_ps(One, A_Blend), Zero), Real255));

                __m256i OutputPixel = _mm256_or_si256(
                                      _mm256_or_si256(R_Out, _mm256_slli_epi32(G_Out, 8)),
                                      _mm256_or_si256(_mm256_slli_epi32(B_Out, 16), _mm256_slli_epi32(A_Out, 24)));

                _mm256_maskstore_epi32((int *)Pixel, TotalMask, OutputPixel);
            }
#if PACKEDRGB
            PixelX = _mm256_add_ps(PixelX, Four);
#else
            PixelX = _mm256_add_ps(PixelX, Eight);
#endif
        }
    }
}

static void
SSE2_RenderLayer(transform_info T, comp_buffer *Buffer, rectangle RenderRegion)
{
    rectangle LayerBounds = ClipRectangle( T.ClipRect,
                                           RenderRegion );
    // Remember: since bitmaps are packed in 4x4 cubes, we always need to be aligned.
    LayerBounds.Min.x -= LayerBounds.Min.x % 4;
    LayerBounds.Min.y -= LayerBounds.Min.y % 4;

    uint16 WidthP, HeightP;
    Bitmap_CalcPackedDimensions(Buffer->Width, Buffer->Height, &WidthP, &HeightP);

    uint8 *TexPTR = (uint8 *)T.SourceBuffer;
    Assert(LayerBounds.Max.x <= Buffer->Width);
    Assert(LayerBounds.Max.y <= Buffer->Height);

    __m128 XAxisPX = _mm_set1_ps(T.XAxisPX);
    __m128 XAxisPY = _mm_set1_ps(T.XAxisPY);
    __m128 YAxisPX = _mm_set1_ps(T.YAxisPX);
    __m128 YAxisPY = _mm_set1_ps(T.YAxisPY);

    __m128 LayerWidth = _mm_set1_ps(T.LayerWidth);
    __m128i LayerWidthMinusOne = _mm_set1_epi32(T.LayerWidth - 1);
    __m128i FullLayerWidth4i = _mm_set1_epi32(T.FullLayerWidth*4);
    __m128 LayerHeight = _mm_set1_ps(T.LayerHeight);
    __m128i LayerHeightMinusOne = _mm_set1_epi32(T.LayerHeight - 1);
    __m128 LayerOpacity = _mm_set1_ps(T.LayerOpacity);
    __m128 OriginX = _mm_set1_ps(T.OriginX);
    __m128 OriginY = _mm_set1_ps(T.OriginY);

    __m128 ClipPrevent = _mm_set1_ps(0.001f);
    __m128 One = _mm_set1_ps(1);
    __m128 Two = _mm_set1_ps(2);
    __m128 Zero = _mm_set1_ps(0);
    __m128 ZeroPointFive = _mm_set1_ps(0.5);
    __m128i Onei = _mm_set1_epi32(1);
    __m128 Four = _mm_set1_ps(4);
    __m128i FF = _mm_set1_epi32(0xFF);
    __m128i BottomTwoBits = _mm_set1_epi32(0x03);
    __m128i Fouri = _mm_set1_epi32(4);
    __m128i Sixteeni = _mm_set1_epi32(16);
    __m128 Reg255 = _mm_set1_ps(255.0f);
    __m128 Norm255 = _mm_set1_ps(1/255.0f);

    // NOTE(fox):  Each loop operates on 4 pixels, 4 horizontal by 1 vertical.

    for (int32 Y = LayerBounds.Min.y; Y < LayerBounds.Max.y; Y++)
    {
        __m128 PixelX = _mm_setr_ps((real32)LayerBounds.Min.x,
                                    (real32)LayerBounds.Min.x+1,
                                    (real32)LayerBounds.Min.x+2,
                                    (real32)LayerBounds.Min.x+3);

        __m128 PixelY = _mm_set1_ps((real32)Y);
        __m128 StartVectorY = _mm_sub_ps(PixelY, OriginY);

        for (int32 X = LayerBounds.Min.x; X < LayerBounds.Max.x; X += 4)
        {

            __m128 StartVectorX = _mm_sub_ps(PixelX, OriginX);

            uint32 XLookup = (X >> 2)*16 + (X % 4);
            uint32 YLookup = (Y >> 2)*(WidthP*4) + (Y % 4)*4;
            uint32 PixelToSeek = XLookup + YLookup;
            uint8 *Pixel = (uint8 *)Buffer->PackedBuffer + PixelToSeek*Buffer->BytesPerPixel;

            __m128 U = _mm_add_ps(_mm_mul_ps(StartVectorX, XAxisPX), _mm_mul_ps(StartVectorY, XAxisPY));
            __m128 V = _mm_add_ps(_mm_mul_ps(StartVectorX, YAxisPX), _mm_mul_ps(StartVectorY, YAxisPY));

            __m128i LayerMask = _mm_castps_si128(_mm_and_ps(_mm_and_ps(_mm_cmpge_ps(U, Zero), _mm_cmplt_ps(U, One)),
                                                            _mm_and_ps(_mm_cmpge_ps(V, Zero), _mm_cmplt_ps(V, One))));

            if (_mm_movemask_epi8(LayerMask))
            {
                U = _mm_max_ps(_mm_min_ps(One, U), Zero);
                V = _mm_max_ps(_mm_min_ps(One, V), Zero);

                __m128 TexXFull = _mm_mul_ps(U, LayerWidth);
                __m128 TexYFull = _mm_mul_ps(V, LayerHeight);
                __m128i TexXInt = _mm_cvttps_epi32(TexXFull);
                __m128i TexXIntPlusOne = _mm_add_epi32(TexXInt, _mm_and_si128(_mm_cmplt_epi32(TexXInt, LayerWidthMinusOne), Onei));
                __m128i TexYInt = _mm_cvttps_epi32(TexYFull);
                __m128i TexYIntPlusOne = _mm_add_epi32(TexYInt, _mm_and_si128(_mm_cmplt_epi32(TexYInt, LayerHeightMinusOne), Onei));

                __m128 TexX = _mm_sub_ps(TexXFull, _mm_cvtepi32_ps(TexXInt));
                __m128 TexY = _mm_sub_ps(TexYFull, _mm_cvtepi32_ps(TexYInt));
                __m128 TexXInv     = _mm_sub_ps(One, TexX);
                __m128 TexYInv     = _mm_sub_ps(One, TexY);
                __m128 TexBothXInv = _mm_mul_ps(TexXInv, TexY);
                __m128 TexBothYInv = _mm_mul_ps(TexX, TexYInv);
                __m128 TexBoth     = _mm_mul_ps(TexY, TexX);
                __m128 TexBothInv  = _mm_mul_ps(TexXInv, TexYInv);

                __m128i XLookup =        _mm_add_epi32(_mm_mullo_epi32(_mm_srli_epi32(TexXInt, 2), Sixteeni),
                                                    _mm_and_si128(TexXInt, BottomTwoBits));
                __m128i YLookup =        _mm_add_epi32(_mm_mullo_epi32(_mm_srli_epi32(TexYInt, 2), FullLayerWidth4i),
                                                    _mm_mullo_epi32(_mm_and_si128(TexYInt, BottomTwoBits), Fouri));
                __m128i XLookupPlusOne = _mm_add_epi32(_mm_mullo_epi32(_mm_srli_epi32(TexXIntPlusOne, 2), Sixteeni),
                                                    _mm_and_si128(TexXIntPlusOne, BottomTwoBits));
                __m128i YLookupPlusOne = _mm_add_epi32(_mm_mullo_epi32(_mm_srli_epi32(TexYIntPlusOne, 2), FullLayerWidth4i),
                                                    _mm_mullo_epi32(_mm_and_si128(TexYIntPlusOne, BottomTwoBits), Fouri));

                __m128i PixelLookupTL = _mm_add_epi32(XLookup, YLookup);
                __m128i PixelLookupTR = _mm_add_epi32(XLookupPlusOne, YLookup);
                __m128i PixelLookupBL = _mm_add_epi32(XLookup, YLookupPlusOne);
                __m128i PixelLookupBR = _mm_add_epi32(XLookupPlusOne, YLookupPlusOne);

                // SSE lacks gathering, so we have no choice but to manually
                // look up each pixel's four bilinear samples in scalar.

                uint32 S_PixelLookupTL0 = _mm_cvtsi128_si32(PixelLookupTL);
                uint32 S_PixelLookupTR0 = _mm_cvtsi128_si32(PixelLookupTR);
                uint32 S_PixelLookupBL0 = _mm_cvtsi128_si32(PixelLookupBL);
                uint32 S_PixelLookupBR0 = _mm_cvtsi128_si32(PixelLookupBR);
                uint32 S_PixelsTL0 = *(uint32 *)(TexPTR + S_PixelLookupTL0*4);
                uint32 S_PixelsTR0 = *(uint32 *)(TexPTR + S_PixelLookupTR0*4);
                uint32 S_PixelsBL0 = *(uint32 *)(TexPTR + S_PixelLookupBL0*4);
                uint32 S_PixelsBR0 = *(uint32 *)(TexPTR + S_PixelLookupBR0*4);

                uint32 S_PixelLookupTL1 = _mm_cvtsi128_si32(_mm_srli_si128(PixelLookupTL, 4));
                uint32 S_PixelLookupTR1 = _mm_cvtsi128_si32(_mm_srli_si128(PixelLookupTR, 4));
                uint32 S_PixelLookupBL1 = _mm_cvtsi128_si32(_mm_srli_si128(PixelLookupBL, 4));
                uint32 S_PixelLookupBR1 = _mm_cvtsi128_si32(_mm_srli_si128(PixelLookupBR, 4));
                uint32 S_PixelsTL1 = *(uint32 *)(TexPTR + S_PixelLookupTL1*4);
                uint32 S_PixelsTR1 = *(uint32 *)(TexPTR + S_PixelLookupTR1*4);
                uint32 S_PixelsBL1 = *(uint32 *)(TexPTR + S_PixelLookupBL1*4);
                uint32 S_PixelsBR1 = *(uint32 *)(TexPTR + S_PixelLookupBR1*4);

                uint32 S_PixelLookupTL2 = _mm_cvtsi128_si32(_mm_srli_si128(PixelLookupTL, 8));
                uint32 S_PixelLookupTR2 = _mm_cvtsi128_si32(_mm_srli_si128(PixelLookupTR, 8));
                uint32 S_PixelLookupBL2 = _mm_cvtsi128_si32(_mm_srli_si128(PixelLookupBL, 8));
                uint32 S_PixelLookupBR2 = _mm_cvtsi128_si32(_mm_srli_si128(PixelLookupBR, 8));
                uint32 S_PixelsTL2 = *(uint32 *)(TexPTR + S_PixelLookupTL2*4);
                uint32 S_PixelsTR2 = *(uint32 *)(TexPTR + S_PixelLookupTR2*4);
                uint32 S_PixelsBL2 = *(uint32 *)(TexPTR + S_PixelLookupBL2*4);
                uint32 S_PixelsBR2 = *(uint32 *)(TexPTR + S_PixelLookupBR2*4);

                uint32 S_PixelLookupTL3 = _mm_cvtsi128_si32(_mm_srli_si128(PixelLookupTL, 12));
                uint32 S_PixelLookupTR3 = _mm_cvtsi128_si32(_mm_srli_si128(PixelLookupTR, 12));
                uint32 S_PixelLookupBL3 = _mm_cvtsi128_si32(_mm_srli_si128(PixelLookupBL, 12));
                uint32 S_PixelLookupBR3 = _mm_cvtsi128_si32(_mm_srli_si128(PixelLookupBR, 12));
                uint32 S_PixelsTL3 = *(uint32 *)(TexPTR + S_PixelLookupTL3*4);
                uint32 S_PixelsTR3 = *(uint32 *)(TexPTR + S_PixelLookupTR3*4);
                uint32 S_PixelsBL3 = *(uint32 *)(TexPTR + S_PixelLookupBL3*4);
                uint32 S_PixelsBR3 = *(uint32 *)(TexPTR + S_PixelLookupBR3*4);

                __m128i PixelsTL = _mm_setr_epi32(S_PixelsTL0, S_PixelsTL1, S_PixelsTL2, S_PixelsTL3);
                __m128i PixelsTR = _mm_setr_epi32(S_PixelsTR0, S_PixelsTR1, S_PixelsTR2, S_PixelsTR3);
                __m128i PixelsBL = _mm_setr_epi32(S_PixelsBL0, S_PixelsBL1, S_PixelsBL2, S_PixelsBL3);
                __m128i PixelsBR = _mm_setr_epi32(S_PixelsBR0, S_PixelsBR1, S_PixelsBR2, S_PixelsBR3);

                __m128 R_TexTL = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(               PixelsTL,      FF)), Norm255);
                __m128 G_TexTL = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_srli_epi32(PixelsTL, 8),  FF)), Norm255);
                __m128 B_TexTL = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_srli_epi32(PixelsTL, 16), FF)), Norm255);
                __m128 A_TexTL = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_srli_epi32(PixelsTL, 24), FF)), Norm255);

                __m128 R_TexTR = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(               PixelsTR,      FF)), Norm255);
                __m128 G_TexTR = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_srli_epi32(PixelsTR, 8),  FF)), Norm255);
                __m128 B_TexTR = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_srli_epi32(PixelsTR, 16), FF)), Norm255);
                __m128 A_TexTR = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_srli_epi32(PixelsTR, 24), FF)), Norm255);

                __m128 R_TexBL = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(               PixelsBL,      FF)), Norm255);
                __m128 G_TexBL = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_srli_epi32(PixelsBL, 8),  FF)), Norm255);
                __m128 B_TexBL = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_srli_epi32(PixelsBL, 16), FF)), Norm255);
                __m128 A_TexBL = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_srli_epi32(PixelsBL, 24), FF)), Norm255);

                __m128 R_TexBR = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(               PixelsBR,      FF)), Norm255);
                __m128 G_TexBR = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_srli_epi32(PixelsBR, 8),  FF)), Norm255);
                __m128 B_TexBR = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_srli_epi32(PixelsBR, 16), FF)), Norm255);
                __m128 A_TexBR = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_srli_epi32(PixelsBR, 24), FF)), Norm255);

                __m128 R_Col = _mm_add_ps(_mm_add_ps(_mm_mul_ps(TexBothInv,  R_TexTL),
                                                     _mm_mul_ps(TexBothYInv, R_TexTR)),
                                          _mm_add_ps(_mm_mul_ps(TexBothXInv, R_TexBL),
                                                     _mm_mul_ps(TexBoth,     R_TexBR)));
                __m128 G_Col = _mm_add_ps(_mm_add_ps(_mm_mul_ps(TexBothInv,  G_TexTL),
                                                     _mm_mul_ps(TexBothYInv, G_TexTR)),
                                          _mm_add_ps(_mm_mul_ps(TexBothXInv, G_TexBL),
                                                     _mm_mul_ps(TexBoth,     G_TexBR)));
                __m128 B_Col = _mm_add_ps(_mm_add_ps(_mm_mul_ps(TexBothInv,  B_TexTL),
                                                     _mm_mul_ps(TexBothYInv, B_TexTR)),
                                          _mm_add_ps(_mm_mul_ps(TexBothXInv, B_TexBL),
                                                     _mm_mul_ps(TexBoth,     B_TexBR)));
                __m128 A_Col = _mm_add_ps(_mm_add_ps(_mm_mul_ps(TexBothInv,  A_TexTL),
                                                     _mm_mul_ps(TexBothYInv, A_TexTR)),
                                          _mm_add_ps(_mm_mul_ps(TexBothXInv, A_TexBL),
                                                     _mm_mul_ps(TexBoth,     A_TexBR)));


                __m128i R_Out, G_Out, B_Out, A_Out;

                __m128 LayerAlpha = _mm_mul_ps(A_Col, LayerOpacity);
                __m128 LayerAlphaInv = _mm_sub_ps(One, LayerAlpha);

                __m128 R_Colx2  = _mm_mul_ps(R_Col, Two);
                __m128 R_ColInv = _mm_sub_ps(One, R_Col);

                __m128 G_Colx2  = _mm_mul_ps(G_Col, Two);
                __m128 G_ColInv = _mm_sub_ps(One, G_Col);

                __m128 B_Colx2  = _mm_mul_ps(B_Col, Two);
                __m128 B_ColInv = _mm_sub_ps(One, B_Col);

                __m128 R_Blend = R_Col;
                __m128 G_Blend = G_Col;
                __m128 B_Blend = B_Col;
                __m128 A_Blend = LayerAlpha;

                if (!_mm_movemask_epi8(_mm_cvtps_epi32(_mm_cmpeq_ps(LayerAlpha, One))) || T.BlendMode != blend_normal)
                {
                    __m128i DestPixel = _mm_loadu_si128((const __m128i *)Pixel);
                    __m128 R_Dest = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(               DestPixel,      FF)), Norm255);
                    __m128 G_Dest = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_srli_epi32(DestPixel, 8),  FF)), Norm255);
                    __m128 B_Dest = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_srli_epi32(DestPixel, 16), FF)), Norm255);
                    __m128 A_Dest = _mm_mul_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_srli_epi32(DestPixel, 24), FF)), Norm255);

                    switch (T.BlendMode)
                    {
                        case blend_normal:
                        {
                        } break;
                        case blend_multiply:
                        {
                            R_Blend  = _mm_mul_ps(R_Dest, R_Col);
                            G_Blend  = _mm_mul_ps(G_Dest, G_Col);
                            B_Blend  = _mm_mul_ps(B_Dest, B_Col);
                        } break;
                        case blend_colorburn:
                        {
                            // NOTE(fox): A small amount is added to Col since images with zero for alpha may also zero out the
                            // color channels, causing black clipping.
                            R_Blend  = _mm_sub_ps(One, _mm_div_ps(_mm_sub_ps(One, R_Dest), _mm_add_ps(R_Col, ClipPrevent)));
                            G_Blend  = _mm_sub_ps(One, _mm_div_ps(_mm_sub_ps(One, G_Dest), _mm_add_ps(G_Col, ClipPrevent)));
                            B_Blend  = _mm_sub_ps(One, _mm_div_ps(_mm_sub_ps(One, B_Dest), _mm_add_ps(B_Col, ClipPrevent)));
                        } break;
                        case blend_linearburn:
                        {
                            R_Blend  = _mm_sub_ps(_mm_add_ps(R_Dest, R_Col), One);
                            G_Blend  = _mm_sub_ps(_mm_add_ps(G_Dest, G_Col), One);
                            B_Blend  = _mm_sub_ps(_mm_add_ps(B_Dest, B_Col), One);
                        } break;
                        case blend_add:
                        {
                            R_Blend  = _mm_add_ps(R_Dest, R_Col);
                            G_Blend  = _mm_add_ps(G_Dest, G_Col);
                            B_Blend  = _mm_add_ps(B_Dest, B_Col);
                        } break;
                        case blend_screen:
                        {
                            R_Blend  = _mm_sub_ps(One, _mm_mul_ps(_mm_sub_ps(One, R_Dest), R_ColInv));
                            G_Blend  = _mm_sub_ps(One, _mm_mul_ps(_mm_sub_ps(One, G_Dest), G_ColInv));
                            B_Blend  = _mm_sub_ps(One, _mm_mul_ps(_mm_sub_ps(One, B_Dest), B_ColInv));
                        } break;
                        case blend_overlay:
                        {
                            __m128 R_Mask  = _mm_cmp_ps(R_Dest,  ZeroPointFive, 1);
                            __m128 G_Mask  = _mm_cmp_ps(G_Dest,  ZeroPointFive, 1);
                            __m128 B_Mask  = _mm_cmp_ps(B_Dest,  ZeroPointFive, 1);
                            __m128 R_Lower = _mm_mul_ps(Two, _mm_mul_ps(R_Dest, R_Col));
                            __m128 G_Lower = _mm_mul_ps(Two, _mm_mul_ps(G_Dest, G_Col));
                            __m128 B_Lower = _mm_mul_ps(Two, _mm_mul_ps(B_Dest, B_Col));
                            __m128 R_Upper = _mm_sub_ps(One, _mm_mul_ps(Two, _mm_mul_ps(_mm_sub_ps(One, R_Dest),  R_ColInv)));
                            __m128 G_Upper = _mm_sub_ps(One, _mm_mul_ps(Two, _mm_mul_ps(_mm_sub_ps(One, G_Dest),  G_ColInv)));
                            __m128 B_Upper = _mm_sub_ps(One, _mm_mul_ps(Two, _mm_mul_ps(_mm_sub_ps(One, B_Dest),  B_ColInv)));
                            R_Blend = _mm_blendv_ps(R_Upper, R_Lower, R_Mask);
                            G_Blend = _mm_blendv_ps(G_Upper, G_Lower, G_Mask);
                            B_Blend = _mm_blendv_ps(B_Upper, B_Lower, B_Mask);
                        } break;
                        case blend_softlight:
                        {
                            // using Pegtop's equation
                            R_Blend  = _mm_add_ps(_mm_mul_ps(_mm_sub_ps(One, R_Colx2), _mm_mul_ps(R_Dest, R_Dest)), _mm_mul_ps(R_Colx2, R_Dest));
                            G_Blend  = _mm_add_ps(_mm_mul_ps(_mm_sub_ps(One, G_Colx2), _mm_mul_ps(G_Dest, G_Dest)), _mm_mul_ps(G_Colx2, G_Dest));
                            B_Blend  = _mm_add_ps(_mm_mul_ps(_mm_sub_ps(One, B_Colx2), _mm_mul_ps(B_Dest, B_Dest)), _mm_mul_ps(B_Colx2, B_Dest));
                        } break;
                        case blend_hardlight:
                        {
                            __m128 R_Mask   = _mm_cmp_ps(R_Dest,  ZeroPointFive, 13);
                            __m128 G_Mask   = _mm_cmp_ps(G_Dest,  ZeroPointFive, 13);
                            __m128 B_Mask   = _mm_cmp_ps(B_Dest,  ZeroPointFive, 13);
                            __m128 R_Lower  = _mm_mul_ps(Two, _mm_mul_ps(R_Dest, R_Col));
                            __m128 G_Lower  = _mm_mul_ps(Two, _mm_mul_ps(G_Dest, G_Col));
                            __m128 B_Lower  = _mm_mul_ps(Two, _mm_mul_ps(B_Dest, B_Col));
                            __m128 R_Upper  = _mm_sub_ps(One, _mm_mul_ps(Two, _mm_mul_ps(_mm_sub_ps(One, R_Dest),  R_ColInv)));
                            __m128 G_Upper  = _mm_sub_ps(One, _mm_mul_ps(Two, _mm_mul_ps(_mm_sub_ps(One, G_Dest),  G_ColInv)));
                            __m128 B_Upper  = _mm_sub_ps(One, _mm_mul_ps(Two, _mm_mul_ps(_mm_sub_ps(One, B_Dest),  B_ColInv)));
                            R_Blend = _mm_blendv_ps(R_Upper, R_Lower, R_Mask);
                            G_Blend = _mm_blendv_ps(G_Upper, G_Lower, G_Mask);
                            B_Blend = _mm_blendv_ps(B_Upper, B_Lower, B_Mask);
                        } break;
                        case blend_subtract:
                        {
                            R_Blend  = _mm_sub_ps(R_Dest, R_Col);
                            G_Blend  = _mm_sub_ps(G_Dest, G_Col);
                            B_Blend  = _mm_sub_ps(B_Dest, B_Col);
                        } break;
                        case blend_divide:
                        {
                            R_Blend  = _mm_div_ps(R_Dest, _mm_add_ps(R_Col, ClipPrevent));
                            G_Blend  = _mm_div_ps(G_Dest, _mm_add_ps(G_Col, ClipPrevent));
                            B_Blend  = _mm_div_ps(B_Dest, _mm_add_ps(B_Col, ClipPrevent));
                        } break;
                        case blend_difference:
                        {
                            __m128 R_Lower  = _mm_sub_ps(R_Col, R_Dest);
                            __m128 G_Lower  = _mm_sub_ps(G_Col, G_Dest);
                            __m128 B_Lower  = _mm_sub_ps(B_Col, B_Dest);
                            __m128 R_Upper  = _mm_sub_ps(R_Dest, R_Col);
                            __m128 G_Upper  = _mm_sub_ps(G_Dest, G_Col);
                            __m128 B_Upper  = _mm_sub_ps(B_Dest, B_Col);
                            __m128 R_Mask  = _mm_cmp_ps(R_Lower,  Zero, 14);
                            __m128 G_Mask  = _mm_cmp_ps(G_Lower,  Zero, 14);
                            __m128 B_Mask  = _mm_cmp_ps(B_Lower,  Zero, 14);
                            R_Blend = _mm_blendv_ps(R_Upper, R_Lower, R_Mask);
                            G_Blend = _mm_blendv_ps(G_Upper, G_Lower, G_Mask);
                            B_Blend = _mm_blendv_ps(B_Upper, B_Lower, B_Mask);
                        } break;
                    }

                    R_Blend = _mm_add_ps(_mm_mul_ps(R_Dest, LayerAlphaInv), _mm_mul_ps(R_Blend, LayerAlpha));
                    G_Blend = _mm_add_ps(_mm_mul_ps(G_Dest, LayerAlphaInv), _mm_mul_ps(G_Blend, LayerAlpha));
                    B_Blend = _mm_add_ps(_mm_mul_ps(B_Dest, LayerAlphaInv), _mm_mul_ps(B_Blend, LayerAlpha));

                    // Standard behavior in photo apps is for blend modes to
                    // inherit underlying opacity instead of adding to it.
                    if (T.BlendMode == blend_normal)
                        A_Blend = _mm_add_ps(A_Dest, LayerAlpha);
                    else
                        A_Blend = A_Dest;
                }

                R_Out = _mm_cvtps_epi32(_mm_mul_ps(_mm_max_ps(_mm_min_ps(One, R_Blend), Zero), Reg255));
                G_Out = _mm_cvtps_epi32(_mm_mul_ps(_mm_max_ps(_mm_min_ps(One, G_Blend), Zero), Reg255));
                B_Out = _mm_cvtps_epi32(_mm_mul_ps(_mm_max_ps(_mm_min_ps(One, B_Blend), Zero), Reg255));
                A_Out = _mm_cvtps_epi32(_mm_mul_ps(_mm_max_ps(_mm_min_ps(One, A_Blend), Zero), Reg255));

                __m128i OutputPixel = _mm_or_si128(
                                      _mm_or_si128(R_Out, _mm_slli_epi32(G_Out, 8)),
                                      _mm_or_si128(_mm_slli_epi32(B_Out, 16), _mm_slli_epi32(A_Out, 24)));
                _mm_maskmoveu_si128(OutputPixel, LayerMask, (char *)Pixel);
            }
            PixelX = _mm_add_ps(PixelX, Four);
        }
    }
}

#endif
#endif