good changes

1 files changed, 43 insertions, 47 deletions

diff --git a/src/createcalls.cpp b/src/createcalls.cpp
index e41a9d2..4761a94 100644
--- a/src/createcalls.cpp
+++ b/src/createcalls.cpp
@@ -683,15 +683,38 @@ Property_IsGraphSelected(memory *Memory, property_channel *Property, uint16 *Arr
     return 0;
 }
 
+// TODO(fox): Add different modes (all dupes on top, each dupe above its layer, two for bottom)
+void
+SortUnionTest(memory *Memory, sorted_layer_array *SortedLayerStart, block_layer *StartLayer, 
+                int i, int FauxIncrement, int LayerCount, int Mode)
+{
+    block_layer *PrevLayer = StartLayer;
+    for (int a = i+1; a < LayerCount; a++) {
+        sorted_layer_array *NextSortEntry = &SortedLayerStart[a];
+        uint32 NextIndex_Physical = NextSortEntry->Block_Layer_Index;
+        block_layer *NextLayer = (block_layer *)Memory_Block_AddressAtIndex(Memory, F_Layers, NextIndex_Physical);
+        if (NextLayer->Vertical_Offset == PrevLayer->Vertical_Offset) {
+            if (Mode == 0) {
+                History_Action_Swap(Memory, F_Layers, sizeof(NextLayer->Vertical_Offset), &NextLayer->Vertical_Offset);
+                NextLayer->Vertical_Offset -= 1;
+            } else {
+                NextSortEntry->SortedOffset -= 1;
+            }
+        } else {
+            break;
+        }
+        PrevLayer = NextLayer;
+    }
+}
+
 static void
 Project_Layer_Duplicate(project_data *File, project_state *State, memory *Memory,
-                        sorted_comp_array *SortedCompArray, sorted_layer_array *SortedLayerArray, v2 Offset, bool32 FakeOnly)
+                        sorted_comp_array *SortedCompArray, sorted_layer_array *SortedLayerArray, v2 Offset, bool32 FakeOnly, bool32 NewPrecomp)
 {
     for (int c = 0; c < File->Comp_Count; c++) {
         sorted_comp_array SortedCompStart = SortedCompArray[c];
         sorted_layer_array *SortedLayerStart = Sorted_GetLayerStart(SortedLayerArray, SortedCompArray, c);
         int LayerCount = SortedCompStart.LayerCount + SortedCompStart.FakeLayerCount;
-        int Increment = 0;
         for (int i = 0; i < LayerCount; i++) 
         {
             sorted_layer_array SortEntry = SortedLayerStart[i];
@@ -706,23 +729,16 @@ Project_Layer_Duplicate(project_data *File, project_state *State, memory *Memory
                 History_Action_Block_Swap(Memory, F_Layers, NewLayer);
                 *NewLayer = *Layer;
 
+                if (NewPrecomp && Layer->IsPrecomp) {
+                    NewLayer->Block_Source_Index = Layer_Precomp_CopyContents();
+                }
+
                 Assert(Layer->Block_Effect_Count == 0);
 
                 Layer_Select(Memory, State, Memory_Block_LazyIndexAtAddress(Memory, F_Layers, NewLayer));
                 NewLayer->Vertical_Offset--;
 
-                for (int a = i+1; a < LayerCount; a++) {
-                    sorted_layer_array PrevSortEntry = SortedLayerStart[a-1];
-                    uint32 PrevIndex_Physical = PrevSortEntry.Block_Layer_Index;
-                    block_layer *PrevLayer = (block_layer *)Memory_Block_AddressAtIndex(Memory, F_Layers, PrevIndex_Physical);
-                    sorted_layer_array NextSortEntry = SortedLayerStart[a];
-                    uint32 NextIndex_Physical = NextSortEntry.Block_Layer_Index;
-                    block_layer *NextLayer = (block_layer *)Memory_Block_AddressAtIndex(Memory, F_Layers, NextIndex_Physical);
-                    if (NextLayer->Vertical_Offset == PrevLayer->Vertical_Offset)
-                        NextLayer->Vertical_Offset -= 1;
-                    else
-                        break;
-                }
+                SortUnionTest(Memory, SortedLayerStart, NewLayer, i, 0, LayerCount, 0);
     
                 Assert(!NewLayer->x.Keyframe_Count);
                 Assert(!NewLayer->y.Keyframe_Count);
@@ -738,15 +754,18 @@ Project_Layer_Duplicate(project_data *File, project_state *State, memory *Memory
                 History_Action_Swap(Memory, F_File, sizeof(File->Layer_Count), &File->Layer_Count);
                 File->Layer_Count++;
     
-                Increment++;
             } else {
-                // History_Action_Swap(Memory, F_Layers, sizeof(Layer->Vertical_Offset), &Layer->Vertical_Offset);
                 Layer->IsSelected = false;
             }
         }
     }
 }
 
+// TODO(fox): We may need a way to recalculate width/height when points are
+// moved since selection depends on it. 
+// TODO(fox): We could also write better selection code for shapes that
+// actually tests using the bezier path (preferrable).
+
 static void
 Project_ShapeLayer_New(project_data *File, project_state *State, memory *Memory)
 {
@@ -767,6 +786,14 @@ Project_ShapeLayer_New(project_data *File, project_state *State, memory *Memory)
 
     shape_layer *Shape = &File->UI.Shape;
 
+    Layer->Block_Composition_Index = File->PrincipalCompIndex;
+    if (State->MostRecentlySelectedLayer == -1) {
+        Layer->Block_Composition_Index = File->PrincipalCompIndex;
+    } else {
+        // LayerIterate_DeepestPrecomp(State, Memory, CompIndex, ExtraT, Center,
+        //                     SortedCompArray, SortedLayerArray, SelectionCount, SelectedLayerIndex, SelectedPrecompIndex)
+    }
+    // Rect mode
     if (State->Interact_Modifier == 1) {
         v2 *CompPoint = (v2 *)&State->Interact_Offset[0];
         for (int i = 0; i < 4; i++) {
@@ -896,37 +923,6 @@ void Source_UICreateButton(project_data *File, project_state *State, memory *Mem
     Source_DeselectAll(File, Memory);
 }
 
-void Precomp_UIDuplicate(project_data *File, project_state *State, memory *Memory, uint16 CompIndex,
-                           sorted_comp_array SortedCompStart, sorted_layer_array *SortedLayerStart)
-{
-    block_layer *Layer = NULL;
-    for (int i = SortedCompStart.LayerCount - 1; i >= 0; i--)
-    {
-        sorted_layer_array SortEntry = SortedLayerStart[i];
-        uint32 Index_Physical = SortEntry.Block_Layer_Index;
-        Layer = (block_layer *)Memory_Block_AddressAtIndex(Memory, F_Layers, Index_Physical);
-        if (Layer->IsSelected) {
-            break;
-        }
-    }
-    if (Layer) {
-        block_layer *DupeLayer = Layer_Init(File, Memory);
-        *DupeLayer = *Layer;
-        DupeLayer->Vertical_Offset += 1;
-        for (int h = 0; h < AmountOf(Layer->Property); h++) {
-            property_channel *Property = &Layer->Property[h];
-            if (Property->Block_Bezier_Count) {
-                property_channel *DupeProperty = &DupeLayer->Property[h];
-                DupeProperty->Block_Bezier_Index[0] = Memory_Block_AllocateNew(Memory, F_Bezier);
-                block_bezier *Bezier = (block_bezier *)Memory_Block_AddressAtIndex(Memory, F_Bezier, Property->Block_Bezier_Index[0]);
-                block_bezier *DupeBezier = (block_bezier *)Memory_Block_AddressAtIndex(Memory, F_Bezier, DupeProperty->Block_Bezier_Index[0], 0);
-                Bezier->Occupied = true;
-                *DupeBezier = *Bezier;
-            }
-        }
-    }
-}
-
 void Precomp_UIDelete(project_data *File, project_state *State, memory *Memory, uint16 CompIndex,
                            sorted_comp_array SortedCompStart, sorted_layer_array *SortedLayerStart)
 {