diff options
Diffstat (limited to 'layer.cpp')
| -rw-r--r-- | layer.cpp | 206 |
1 files changed, 206 insertions, 0 deletions
diff --git a/layer.cpp b/layer.cpp new file mode 100644 index 0000000..b8355ed --- /dev/null +++ b/layer.cpp @@ -0,0 +1,206 @@ +internal temp_layer_list +FindSelectedLayerIndex(project_data *File, int16 NumberOfSelectedLayers) +{ + temp_layer_list List = {}; + if (!NumberOfSelectedLayers) return List; + int16 i = 0; + int16 n = 0; + while (NumberOfSelectedLayers) + { + if (File->Layer[i]->IsSelected == true) { + List.LayerIndex[n] = i; + n++; + NumberOfSelectedLayers--; + } + i++; + Assert(i <= File->NumberOfLayers); + } + return List; +} + +internal transform_info +CalculateTransforms(project_layer *Layer, pixel_buffer *Buffer); + +internal bool32 +TestPointInLayer(project_layer *Layer, pixel_buffer *Buffer, v2 UV) +{ + bool32 Result = false; + real32 X = UV.x*Buffer->Width; + real32 Y = UV.y*Buffer->Height; + transform_info T = CalculateTransforms(Layer, Buffer); + real32 StartVectorX = X - T.OriginX; + real32 StartVectorY = Y - T.OriginY; + real32 LayerU = (StartVectorX * T.XAxisPX) + (StartVectorY * T.XAxisPY); + real32 LayerV = (StartVectorX * T.YAxisPX) + (StartVectorY * T.YAxisPY); + if (LayerU <= 1.0f && LayerU >= 0.0f && LayerV <= 1.0f && LayerV >= 0.0f) { + Result = true; + } + return Result; +} + +internal void +CalculateAnchorOffset(project_layer *, real32, uint16); + +internal void +InteractProperty(int16 a, project_data *File, project_state *State, bool32 Ended, real32 Value, memory *Memory) +{ + temp_layer_list List = FindSelectedLayerIndex(File, State->NumberOfSelectedLayers); + for (int i = 0; i < State->NumberOfSelectedLayers; i++) { + project_layer *Layer = File->Layer[List.LayerIndex[i]]; + // keyframe *Keyframe = InsertKeyframeAtFrame(&File->LayerPTR[State->SelectedLayerIndex[r]]->Property[Index], *State, File->CurrentFrame, Memory, Cache); + if (a == 2) { + CalculateAnchorOffset(Layer, Value, 0); + } else if (a == 3) { + CalculateAnchorOffset(Layer, Value, 1); + } else { + Layer->Property[a].CurrentValue.f += Value; + } + } + // Cache->Interact = Active; + // Cache->InteractIndex = State->SelectedLayerIndex[0]; + if (Ended) + { + State->IsInteracting = false; + // Cache->Interact = Clear; + } + State->UpdateFrame = true; + // Cache->Frame[File->CurrentFrame].Cached = false; +} + +internal void +TransformsInteract(project_data *File, project_state *State, ui *UI, transforms_hotkey_interact Mode) +{ + if (UI->FocusedWindow == focus_timeline) { + temp_layer_list List = FindSelectedLayerIndex(File, State->NumberOfSelectedLayers); + for (int i = 0; i < State->NumberOfSelectedLayers; i++) { + uint16 Index = List.LayerIndex[i]; + if (Mode == sliding_position) { + SwitchBool(File->Layer[Index]->x.IsToggled) + SwitchBool(File->Layer[Index]->y.IsToggled) + } else if (Mode == sliding_anchorpoint) { + SwitchBool(File->Layer[Index]->ax.IsToggled) + SwitchBool(File->Layer[Index]->ay.IsToggled) + } else if (Mode == sliding_rotation) { + SwitchBool(File->Layer[Index]->rotation.IsToggled) + } else if (Mode == sliding_scale) { + SwitchBool(File->Layer[Index]->scale.IsToggled) + } + } + } else if (UI->FocusedWindow == focus_viewport) { + State->IsInteracting = true; + State->TransformsHotkeyInteract = Mode; + } +} + +internal void +SelectLayer(project_layer *Layer, project_state *State, int32 i) +{ + Layer->IsSelected = true; + State->NumberOfSelectedLayers++; + State->MostRecentlySelectedLayer = i; +} + +internal void +DeselectAllLayers(project_data *File, project_state *State) +{ + temp_layer_list List = FindSelectedLayerIndex(File, State->NumberOfSelectedLayers); + for (int i = 0; i < State->NumberOfSelectedLayers; i++) { + uint16 Index = List.LayerIndex[i]; + File->Layer[Index]->IsSelected = false; + } + State->NumberOfSelectedLayers = 0; + State->MostRecentlySelectedLayer = -1; +} + +// NOTE(fox): We probably can't get away with being _this_ minimal about layer +// indexing without making the code massively more complicated down the road; +// keeping an Index value in the layer and just sorting every time the order +// changes probably won't be much of a performance cost. + +internal void +MoveLayersByIncrement(project_data *File, project_state *State, int16 Increment) +{ + bool32 AllowMove = true; + temp_layer_list List = FindSelectedLayerIndex(File, State->NumberOfSelectedLayers); + // The layer list is always sorted, so we should be able to safely check + // whether the first and last layer on the list is the + // top/bottommost-indexed layer. + if ((List.LayerIndex[0] == 0) && (Increment < 0)) + AllowMove = false; + if ((List.LayerIndex[State->NumberOfSelectedLayers - 1] == (File->NumberOfLayers - 1)) && (Increment > 0)) + AllowMove = false; + + if (AllowMove) { + int16 i = 0; + int16 c = 1; + if (Increment < 0) c = -1; + while (i < State->NumberOfSelectedLayers) { + // If selected layers are right next to each other, we have to sort + // them differently. + if ((Increment > 0) && (List.LayerIndex[i + c - 1] == (List.LayerIndex[i+c] - 1))) { + c++; + continue; + } + uint16 Index = List.LayerIndex[i]; + project_layer TopmostLayer = *File->Layer[Index+c]; + if (c <= 1) { + if (Index == State->MostRecentlySelectedLayer) + State->MostRecentlySelectedLayer += Increment; + *File->Layer[Index + Increment] = *File->Layer[Index]; + *File->Layer[Index] = TopmostLayer; + i++; + } else { + int p = c; + while (c > 0) { + if (Index+c == State->MostRecentlySelectedLayer) + State->MostRecentlySelectedLayer += Increment; + project_layer Temp = *File->Layer[Index+c]; + *File->Layer[Index+c] = *File->Layer[Index + c - 1]; + c--; + } + if (Index == State->MostRecentlySelectedLayer) + State->MostRecentlySelectedLayer += Increment; + *File->Layer[Index] = TopmostLayer; + i += p; + c = 1; + } + } + } +} + +/* + +internal bool32 +TestSelectedLayer(project_state *State, uint16 *a, uint16 Index) +{ + bool32 Result = 0; + if (State->NumberOfSelectedLayers == 0) + return Result; + if (Index == 0) { + for (int i = 0; i < State->NumberOfSelectedLayers; i++) { + State->TempSelectedLayerSorted[i] = State->SelectedLayerIndex[i]; + } + bool32 SwapMade = true; + while (SwapMade) { + int Swaps = 0; + for (int i = 0; i < State->NumberOfSelectedLayers - 1; i++) { + if (State->TempSelectedLayerSorted[i] > State->TempSelectedLayerSorted[i+1]) { + int32 Temp = State->TempSelectedLayerSorted[i]; + State->TempSelectedLayerSorted[i] = State->TempSelectedLayerSorted[i+1]; + State->TempSelectedLayerSorted[i+1] = Temp; + Swaps++; + } + } + if (!Swaps) SwapMade = false; + } + } + if (State->TempSelectedLayerSorted[*a] == Index) { + Result = 1; + *a += 1; + } + if (*a >= State->NumberOfSelectedLayers) + *a = 0; + return Result; +} + +*/ |