large changes to bitmap structure

1 files changed, 68 insertions, 50 deletions

diff --git a/prenderer.cpp b/prenderer.cpp
index 5df28f4..7ce738a 100644
--- a/prenderer.cpp
+++ b/prenderer.cpp
@@ -1,26 +1,26 @@
 
-internal void
+static void
 PushRect(rectangle RenderRegion);
 
-internal void
+static void
 RenderLayerNeon(project_layer *Layer, pixel_buffer *Buffer, rectangle RenderRegion);
-internal void
-AVX2_RenderLayer(transform_info TransformInfo, pixel_buffer *Buffer, rectangle RenderRegion);
-internal void
-SSE2_RenderLayer(transform_info TransformInfo, pixel_buffer *Buffer, rectangle RenderRegion);
-internal void
-Fallback_RenderLayer(transform_info TransformInfo, pixel_buffer *Buffer, rectangle RenderRegion);
-
-internal bool32
+static void
+AVX2_RenderLayer(transform_info TransformInfo, comp_buffer *Buffer, rectangle RenderRegion);
+static void
+SSE2_RenderLayer(transform_info TransformInfo, comp_buffer *Buffer, rectangle RenderRegion);
+static void
+Fallback_RenderLayer(transform_info TransformInfo, comp_buffer *Buffer, rectangle RenderRegion);
+
+static bool32
 CheckQueue(render_queue RenderInfo, uint16 Index);
 
 // for the anchor point moving UI
-internal void
+static void
 CalculateAnchorOffset(project_layer *Layer, real32 Value, uint16 Dir)
 {
     v2 Result = {};
     transform_info TransformInfo;
-    image_source *Source = (image_source *)Layer->RenderInfo;
+    source *Source = Layer->Source;
 
     real32 Rad = (Layer->rotation.CurrentValue.f * (PI / 180));
     real32 s = Layer->scale.CurrentValue.f;
@@ -28,28 +28,28 @@ CalculateAnchorOffset(project_layer *Layer, real32 Value, uint16 Dir)
     if (Dir == 0) {
         v2 XAxis = V2(cos(Rad), sin(Rad)) * (Value / s);
         Layer->x.CurrentValue.f += Value;
-        Layer->ax.CurrentValue.f += XAxis.x/Source->Raster.Width;
-        Layer->ay.CurrentValue.f -= XAxis.y/Source->Raster.Height;
+        Layer->ax.CurrentValue.f += XAxis.x/Source->Info.Width;
+        Layer->ay.CurrentValue.f -= XAxis.y/Source->Info.Height;
     } else {
         v2 YAxis = V2(sin(Rad), -cos(Rad)) * (Value / -s);
         Layer->y.CurrentValue.f += Value;
-        Layer->ax.CurrentValue.f -= YAxis.x/Source->Raster.Width;
-        Layer->ay.CurrentValue.f += YAxis.y/Source->Raster.Height;
+        Layer->ax.CurrentValue.f -= YAxis.x/Source->Info.Width;
+        Layer->ay.CurrentValue.f += YAxis.y/Source->Info.Height;
     }
 }
 
-internal transform_info
-CalculateTransforms(project_layer *Layer, pixel_buffer *Buffer)
+static transform_info
+CalculateTransforms(project_layer *Layer, comp_buffer *CompBuffer)
 {
     transform_info TransformInfo;
-    image_source *Source = (image_source *)Layer->RenderInfo;
+    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->Raster.Width * s)*V2(cos(Rad), sin(Rad));
-    v2 YAxis = (Source->Raster.Height * -s)*V2(sin(Rad), -cos(Rad));
+    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;
@@ -62,8 +62,8 @@ CalculateTransforms(project_layer *Layer, pixel_buffer *Buffer)
 
     int32 MaxX = 0;
     int32 MaxY = 0;
-    int32 MinX = Buffer->Width;
-    int32 MinY = Buffer->Height;
+    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++) {
@@ -77,24 +77,30 @@ CalculateTransforms(project_layer *Layer, pixel_buffer *Buffer)
     TransformInfo.XAxisPY = XLengthSq*XAxis.y;
     TransformInfo.YAxisPX = YLengthSq*YAxis.x;
     TransformInfo.YAxisPY = YLengthSq*YAxis.y;
-    TransformInfo.LayerWidth = (real32)Source->Raster.Width;
-    TransformInfo.LayerHeight = (real32)Source->Raster.Height;
-    TransformInfo.FullLayerWidth = Source->Raster.FullWidth;
-    TransformInfo.FullLayerHeight = Source->Raster.FullHeight;
+
+    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 = Buffer->Pitch;
-    TransformInfo.LayerPitch = Source->Raster.Pitch;
+    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 = Source->Raster.EffectBuffer;
+    TransformInfo.SourceBuffer = Layer->BitmapInfo.BitmapBuffer;
 
     return TransformInfo;
 }
 
-internal void
+static void
 EndRenderState(project_state *State)
 {
       IsRendering = false;
@@ -113,21 +119,21 @@ EndRenderState(project_state *State)
 
 }
 
-internal void
+static void
 RenderLayers(render_queue *RenderInfo, rectangle RenderRegion) {
     for (int16 i = 0; i < RenderInfo->State->NumberOfLayersToRender; i++) {
         int16 Idx = RenderInfo->State->LayersToRender[i];
-        if (InstructionMode == avx_enabled)
+        if (InstructionMode == instruction_mode_avx)
             AVX2_RenderLayer(RenderInfo->File->Layer[Idx]->TransformInfo, RenderInfo->CompBuffer, RenderRegion);
-        else if (InstructionMode == sse_enabled)
+        else if (InstructionMode == instruction_mode_sse)
             SSE2_RenderLayer(RenderInfo->File->Layer[Idx]->TransformInfo, RenderInfo->CompBuffer, RenderRegion);
         else
             Fallback_RenderLayer(RenderInfo->File->Layer[Idx]->TransformInfo, RenderInfo->CompBuffer, RenderRegion);
     }
 }
 
-internal void
-QueueCurrentFrame(project_data *File, pixel_buffer *CompBuffer, project_state *State)
+static void
+QueueCurrentFrame(project_data *File, comp_buffer *CompBuffer, project_state *State)
 {
     IsRendering = true;
     render_queue RenderInfo = {File, State, CompBuffer};
@@ -181,7 +187,7 @@ QueueCurrentFrame(project_data *File, pixel_buffer *CompBuffer, project_state *S
 
 
 #if ARM
-internal void
+static void
 RenderLayerNeon(project_layer *Layer, pixel_buffer *Buffer, rectangle RenderRegion)
 {
     float32x4_t XAxisPX = vdupq_n_f32(XAxisP.x);
@@ -362,8 +368,8 @@ RenderLayerNeon(project_layer *Layer, pixel_buffer *Buffer, rectangle RenderRegi
 }
 #else
 
-internal void
-AVX2_RenderLayer(transform_info T, pixel_buffer *Buffer, rectangle RenderRegion)
+static void
+AVX2_RenderLayer(transform_info T, comp_buffer *Buffer, rectangle RenderRegion)
 {
     rectangle LayerBounds = ClipRectangle( T.ClipRect,
                                            RenderRegion );
@@ -439,10 +445,14 @@ AVX2_RenderLayer(transform_info T, pixel_buffer *Buffer, rectangle RenderRegion)
 
             __m256 StartVectorX = _mm256_sub_ps(PixelX, OriginX);
 
+            // TODO(fox): Not unwraping this function may lose a few cycles!
+            uint16 WidthP, HeightP;
+            Bitmap_CalcPackedDimensions(Buffer->Width, Buffer->Height, &WidthP, &HeightP);
+
             uint32 XLookup = (X >> 2)*16 + (X % 4);
-            uint32 YLookup = (Y >> 2)*(Buffer->FullWidth*4) + (Y % 4)*4;
+            uint32 YLookup = (Y >> 2)*(WidthP*4) + (Y % 4)*4;
             uint32 PixelToSeek = XLookup + YLookup;
-            uint8 *Pixel = (uint8 *)Buffer->OriginalBuffer + PixelToSeek*Buffer->BytesPerPixel;
+            uint8 *Pixel = (uint8 *)Buffer->PackedBuffer + PixelToSeek*Buffer->BytesPerPixel;
 
             __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));
@@ -690,8 +700,8 @@ AVX2_RenderLayer(transform_info T, pixel_buffer *Buffer, rectangle RenderRegion)
     }
 }
 
-internal void
-SSE2_RenderLayer(transform_info T, pixel_buffer *Buffer, rectangle RenderRegion)
+static void
+SSE2_RenderLayer(transform_info T, comp_buffer *Buffer, rectangle RenderRegion)
 {
     rectangle LayerBounds = ClipRectangle( T.ClipRect,
                                            RenderRegion );
@@ -752,10 +762,15 @@ SSE2_RenderLayer(transform_info T, pixel_buffer *Buffer, rectangle RenderRegion)
 
             __m128 StartVectorX = _mm_sub_ps(PixelX, OriginX);
 
+
+            // TODO(fox): Not unwraping this function may lose a few cycles!
+            uint16 WidthP, HeightP;
+            Bitmap_CalcPackedDimensions(Buffer->Width, Buffer->Height, &WidthP, &HeightP);
+
             uint32 XLookup = (X >> 2)*16 + (X % 4);
-            uint32 YLookup = (Y >> 2)*(Buffer->FullWidth*4) + (Y % 4)*4;
+            uint32 YLookup = (Y >> 2)*(WidthP*4) + (Y % 4)*4;
             uint32 PixelToSeek = XLookup + YLookup;
-            uint8 *Pixel = (uint8 *)Buffer->OriginalBuffer + PixelToSeek*Buffer->BytesPerPixel;
+            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));
@@ -1040,15 +1055,18 @@ SSE2_RenderLayer(transform_info T, pixel_buffer *Buffer, rectangle RenderRegion)
 
 #endif
 
-internal void
-Fallback_RenderLayer(transform_info T, pixel_buffer *Buffer, rectangle RenderRegion)
+static void
+Fallback_RenderLayer(transform_info T, comp_buffer *Buffer, rectangle RenderRegion)
 {
     rectangle LayerBounds = ClipRectangle( T.ClipRect, RenderRegion);
 
     Assert(LayerBounds.Max.x <= Buffer->Width);
     Assert(LayerBounds.Max.y <= Buffer->Height);
 
-    uint8 *Row = ((uint8 *)Buffer->OriginalBuffer + Buffer->Pitch*(int16)(LayerBounds.Min.y) );
+    uint16 WidthP, HeightP;
+    Bitmap_CalcPackedDimensions(Buffer->Width, Buffer->Height, &WidthP, &HeightP);
+
+    uint8 *Row = ((uint8 *)Buffer->PackedBuffer + WidthP*Buffer->BytesPerPixel*(int16)(LayerBounds.Min.y) );
 
     uint32 Channel = (T.LayerWidth * T.LayerHeight);
     real32 Normalized255 = 1 / 255.0f;
@@ -1123,9 +1141,9 @@ Fallback_RenderLayer(transform_info T, pixel_buffer *Buffer, rectangle RenderReg
                 uint32 PixelD = *(uint32 *)((uint8 *)T.SourceBuffer + PixelToSeek*Buffer->BytesPerPixel);
 #endif
                 XLookup = (X >> 2)*16 + (X % 4);
-                YLookup = (Y >> 2)*(Buffer->FullWidth*4) + (Y % 4)*4;
+                YLookup = (Y >> 2)*(WidthP*4) + (Y % 4)*4;
                 PixelToSeek = XLookup + YLookup;
-                uint32 *Pixel = (uint32 *)((uint8 *)Buffer->OriginalBuffer + PixelToSeek*Buffer->BytesPerPixel);
+                uint32 *Pixel = (uint32 *)((uint8 *)Buffer->PackedBuffer + PixelToSeek*Buffer->BytesPerPixel);
 
                 real32 TexRA = (real32)(PixelA & 0xFF) * Normalized255;
                 real32 TexRB = (real32)(PixelB & 0xFF) * Normalized255;