enum instruction_mode { instruction_mode_scalar, instruction_mode_sse, instruction_mode_avx }; struct cache { void *Address; bool32 Cached; }; enum whattocallthis { Inactive, Active, Clear }; struct cache_pool { cache Frame[2048]; cache Intermediate[3]; whattocallthis Interact; int16 InteractIndex; }; enum memory_table_list { // F = file attributes // P = persistent data, but not file-based // B = cached data, often cleared P_AVInfo, P_SourceBitmapTable, F_Layers, F_Effects, F_Keyframes, F_Strings, B_LayerBitmaps, B_LoadedBitmaps, }; struct memory_table { char *Name; void *Address; uint64 CurrentPosition; uint64 Size; uint32 NumberOfPointers; uint32 PointerIndex; }; struct global_memory { void *Address; uint64 CurrentPosition; uint64 Size; }; struct source; struct cached_bitmap { source *SourceOwner; // Which source it belongs to. Currently used to dereference the bitmap. void *Data; // Unpacked data loaded from the source file. uint32 Frame; // What frame it is. }; struct memory { memory_table Slot[16]; cached_bitmap Bitmap[4096]; }; struct property_channel; struct project_layer; enum display_type { standard, levels }; enum keyframe_type { linear, bezier, hold }; // NOTE(fox): One val slot holds 16 bytes of data. enum var_type { type_real, type_color, type_blendmode }; static char* BlendmodeNames[] = { "Normal", "Multiply", "Color Burn", "Linear Burn", "Add", "Screen", "Overlay", "Soft Light", "Hard Light", "Subtract", "Divide", "Difference" }; enum blend_mode { blend_normal, blend_multiply, blend_colorburn, blend_linearburn, blend_add, blend_screen, blend_overlay, blend_softlight, blend_hardlight, blend_subtract, blend_divide, blend_difference }; union val { real32 f; v4 col; blend_mode blendmode; }; struct keyframe { val Value; int32 FrameNumber; keyframe_type Type; bool32 IsSelected; // The X coordinate for the tangent is in keyframes, and the Y is in units. // Probably should think of something smarter. v2 TangentLeft; v2 TangentRight; }; struct keyframe_block { keyframe Keyframe[MAX_KEYFRAMES_PER_BLOCK]; }; struct property_channel { char *Name; keyframe_block *KeyframeBlock[MAX_KEYFRAME_BLOCKS]; uint16 SortedIndex[MAX_KEYFRAME_BLOCKS * MAX_KEYFRAMES_PER_BLOCK]; uint16 NumberOfKeyframeBlocks; uint16 NumberOfSelectedKeyframes; uint16 NumberOfTotalKeyframes; val CurrentValue; val MaxVal; val MinVal; val ScrubVal; // increment when dragging on sliders, etc. var_type VarType; // TODO(fox): Probably shouldn't store these in the file... // UI val LocalMaxVal; val LocalMinVal; bool32 IsToggled; bool32 IsGraphToggled; real32 GraphLength; // represented in actual screen pixels real32 GraphYOffset; // The size of the window enclosing the graph uint16 GraphWindowHeight; }; struct property_header { char *Name; val Value; var_type VarType; val MinVal; val MaxVal; }; // Information about a particular file. enum source_type { source_type_none, source_type_video, source_type_image }; // Probably best to consider source_info a part of the file data so we don't // have to re-check each source on every project load. (except for AVInfo) struct source_info { // Image and video uint16 Width; uint16 Height; uint16 BytesPerPixel; // Video only real32 FPS; real32 AvgPTSPerFrame; // set by Libav }; struct source { char *Path; source_type SourceType; source_info Info; }; // Bitmaps from files are loaded into these temporary cache blocks. struct layer_bitmap_info { // Image and video void *BitmapBuffer; // Each layer has a persistent bitmap that the source data gets packed into. bool32 ToUpdate = 1; // Video only int32 FrameOffset; // the "true" position of video layers, separate from StartFrame int32 CurrentFrame = -1; // The last frame number rendered to the bitmap. void *AVInfo; // Internal data containing current frame info }; struct comp_buffer { uint16 Width; uint16 Height; uint16 BytesPerPixel; void *PackedBuffer; void *UnpackedBuffer; }; struct effect_header { char *Name; void (*func)(source *, layer_bitmap_info *, memory *, property_channel []); uint16 NumberOfProperties; display_type DisplayType; property_header PropertyHeader[MAX_PROPERTIES_PER_EFFECT]; }; struct effect { char *Name; void (*func)(source *, layer_bitmap_info *, memory *, property_channel []); uint16 NumberOfProperties; display_type DisplayType; property_channel Property[MAX_PROPERTIES_PER_EFFECT]; bool32 UIIsCollapsed = 0; bool32 IsActive = 1; }; struct transform_info { real32 XAxisPX; real32 XAxisPY; real32 YAxisPX; real32 YAxisPY; real32 LayerWidth; real32 LayerHeight; uint32 FullLayerWidth; uint32 FullLayerHeight; real32 LayerOpacity; blend_mode BlendMode; real32 OriginX; real32 OriginY; uint32 BufferPitch; uint32 LayerPitch; rectangle ClipRect; void *SourceBuffer; }; struct project_layer { char *Name; blend_mode BlendMode; union { property_channel Property[8]; struct { property_channel x; property_channel y; property_channel ax; property_channel ay; property_channel rotation; property_channel scale; property_channel opacity; property_channel time; }; }; bool32 IsSelected; source *Source; layer_bitmap_info BitmapInfo; effect *Effect[MAX_EFFECTS]; uint16 NumberOfEffects; int32 StartFrame; int32 EndFrame; uint32 LayerColor; // For rendering transform_info TransformInfo; }; // NOTE(fox): I have no idea how people normally do selection; currently I'm // treating it more "immediate." Instead of updating a selection state as // things are selected, I'm just calling functions that go through all the // layers and keyframes to look for the IsSelected bool. If this causes // lag I'll switch it to the former. struct temp_layer_list { int16 LayerIndex[MAX_LAYERS]; }; struct temp_keyframe_list { keyframe *SelectedKeyframe[50]; uint16 Amount; }; struct project_data { uint16 Width; uint16 Height; uint16 FPS; uint32 NumberOfFrames; int32 StartFrame; int32 EndFrame; int32 CurrentFrame; // NOTE(fox): Currently I'm handling layer sorting by just saying that // their order in memory is the order of the index and manually moving // their positions. project_layer *Layer[MAX_LAYERS]; uint16 NumberOfSelectedLayers; uint16 NumberOfLayers; source Source[MAX_SOURCES]; uint16 NumberOfSources; }; enum tool { DefaultSelect, BrushTool, CropTool, BoxSelect, QuickSelect, PenTool }; enum transforms_hotkey_interact { sliding_position, sliding_anchorpoint, sliding_scale, sliding_rotation }; struct main_sdl { SDL_Texture *Texture; SDL_Event Event; SDL_Window *Window; SDL_Renderer *Renderer; }; // used to determine what to copy/paste, delete, etc enum selection_type { selection_none, selection_layer, selection_effect, selection_keyframe, }; struct project_state { bool32 UpdateKeyframes = 1; bool32 UpdateFrame = 1; // only refreshes frame; set UpdateKeyframes to update animation bool32 DebugDisableCache = 1; tool Tool = DefaultSelect; uint16 LayersToRender[MAX_LAYERS]; uint16 NumberOfLayersToRender; bool32 IsRunning = 1; bool32 IsPlaying; bool32 DemoButton = 1; bool32 GridButton = 1; uint16 NumberOfSelectedLayers; int16 MostRecentlySelectedLayer = -1; // convenience for the properties panel selection_type RecentSelectionType = selection_none; bool32 IsInteracting; transforms_hotkey_interact TransformsHotkeyInteract; int32 MsgTime; // currently in "frames" char *Msg; ImGuiTextFilter filter; // This filter API is pretty ballin'. bool32 RerouteEffects; // Allows shift+space hotkey to gain focus on the effects panel. }; struct brush_tool { real32 Size; real32 Opacity; real32 Hardness; }; enum focused_window { focus_viewport, focus_properties, focus_timeline }; struct ui { real32 TimelineSplit = 600; real32 TimelineZoom; ImVec2 CompZoom; ImVec2 CompPos; // Used to set UI values on the first frame. Some UI setup in Docking takes // more than 1 frame for some reason, so I'm temporarily extending it. bool32 Initializing = 4; // Custom scrolling for the timeline, as ImGui's didn't work well real32 ScrollXOffset; real32 ScrollYOffset; // NOTE(fox): Keeping track of mouse delta myself since the ImGui threshold // dragging API doesn't let you do things like subtract the delta easily. real32 DraggingKeyframeThreshold; real32 DraggingLayerThreshold; real32 DraggingTimelineThreshold; real32 KeyframeSpacing = 6; ImVec2 BoxStart = ImVec2(0,0); ImVec2 BoxEnd = ImVec2(0,0); bool32 BoxSelectActive = false; // Temporary varibles used when zooming in/out v2 TempZoomRatio = V2(1, 1); real32 TempZoomRatioTimeline = 0; real32 TempZoomRatioGraph = 0; focused_window FocusedWindow; // Convenience for adding window-specific hotkeys. bool32 TemporaryUpdateOverride; }; struct imgui_buttonstate { bool32 IsItemHovered; bool32 IsItemActive; bool32 IsItemActivated; bool32 IsItemDeactivated; bool32 LeftClick; bool32 RightClick; }; struct timeline_properties { rectangle Timeline; v2i MainWindow; uint16 WindowPadding; rectangle EffectPanel; rectangle Toolbar; rectangle ColorPanel; bool32 RenderSlidingBrush; uint16 CompX; uint16 CompY; uint16 TimelineZoom; uint16 CompScale; uint16 FramePadding; uint16 LayerPadding; uint16 TimelineCurrentFrame; int16 TimelineCurrentLayer; uint16 InfoTimelineSplit; bool32 DrawTimeline; bool32 DrawEffectPanel; bool32 DrawComp; }; struct sdl_button { bool32 IsDown; bool32 SingleClick; // More precisely, when button is released and no dragging/selecting events are happening. int HeldLength; }; struct sdl_input { v2i Mouse; sdl_button MouseButton[3]; rectangle Selection; }; struct render_queue { project_data *File; project_state *State; comp_buffer *CompBuffer; }; struct thread_info { render_queue *RenderInfo; uint16 Index; }; struct work_queue_entry { char *StringToPrint; }; struct render_entry { rectangle RenderRegion; };