summaryrefslogtreecommitdiff
path: root/main.h
blob: 8e29917f14cdf3ffc7cb35fa05e9e70b08c90847 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
enum instruction_mode {
    instruction_mode_scalar,
#if ARM
    instruction_mode_neon,
#else
    instruction_mode_sse,
    instruction_mode_avx
#endif
};

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
};

struct block_string {
    uint8 Occupied;
    char Char[1024 - sizeof(uint8)];
};

enum interpolation_type
{
    interpolation_type_linear,
    interpolation_type_bezier,
    interpolation_type_hold
};

struct bezier_point {
    v2 Pos[3];
    interpolation_type Type;
    uint16 ImguiID;
    uint8 IsSelected;
};

struct block_bezier {
    uint8 Occupied;
    bezier_point Point[MAX_KEYFRAMES_PER_BLOCK];
};

struct render_state
{
    void *MainCompBuffer;
};

struct project_state
{
    bool32 UpdateKeyframes = 1;
    bool32 UpdateFrame = 1;         // only refreshes frame; set UpdateKeyframes to update animation
    bool32 DebugDisableCache = 1;

    render_state Render;

    // tool Tool = tool_default;
    // pen_state Pen = {};

    bool32 IsRunning = 1;
    bool32 IsPlaying;

    int16 MostRecentlySelectedLayer = -1;
    // selection_type RecentSelectionType = selection_none;

    bool32 IsInteracting;
    real32 InteractCache[6];
    // interact_type InteractType;

    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 project_data
{
    uint8 Occupied;
    uint16 Layer_Count;
    uint16 Source_Count;
    uint16 PrincipalCompIndex;
};

struct block_composition
{
    uint8 Occupied;
    uint16 Width;
    uint16 Height;
    uint16 FPS;
    uint16 BytesPerPixel;

    uint32 Frame_Count;
     int32 Frame_Current;
     int32 Frame_Start;
     int32 Frame_End;
};

enum source_type {
    source_type_none,
    source_type_video,
    source_type_image
};

struct block_source
{
    uint8 Occupied;

    uint16 Block_String_Index;
    // Image and video
    uint16 Width;
    uint16 Height;
    uint16 BytesPerPixel;

    // Video only
    real32 FPS;
    real32 AvgPTSPerFrame; // set by Libav

    source_type SourceType;
};

struct property_header
{
    char *Name;
    real32 DefaultVal;
    real32 MinVal;
    real32 MaxVal;
};

struct property_channel {
    char *Name;
    uint16 Block_Bezier_Index[MAX_KEYFRAME_BLOCKS];
    uint16 Block_Bezier_Count;
    uint16 Keyframe_Count;

    real32 CurrentValue;
    real32 MaxVal;
    real32 MinVal;
    real32 ScrubVal;           // increment when dragging on sliders, etc.

    bool32 IsToggled;
};

struct layer_bitmap_state {
    // Image and video
    bool32 ToUpdate = 1;

    // GL state
    // gl_effect_layer Test;
    // gl_effect_layer TestM;

    // Video state
    int32 CurrentFrame = -1;  // The last frame number rendered to the bitmap. -1 gurantees a load upon layer creation.
    void *AVInfo;             // Internal data containing current frame info
};

struct block_layer {
    uint8 Occupied;

    uint16 Block_String_Index;
    uint16 Block_Source_Index;
    uint16 Block_Composition_Index;

    uint16 Block_Mask_Index[MAX_EFFECTS];
    uint16 Block_Mask_Count;

    uint16 Block_Effect_Index[MAX_MASKS];
    uint16 Block_Effect_Count;

    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;

    int32 Frame_Offset;
    int32 Frame_Start;
    int32 Frame_End;

    uint32 LayerColor;
};


#if 0

struct cached_bitmap {
    uint32 SourceIndex;     // 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 gl_effect_layer {
    bool32 Initialized;
    GLuint Texture;
    GLuint FramebufferObject;
    uint32 Color_Renderbuffer;
    uint32 Stencil_Renderbuffer;
};


// Bitmaps from files are loaded into these temporary cache blocks.


// NOTE(fox): I use the term "comp" (composition) to mean the canvas that is
// being rendered to, since it's what I'm used to from AE.
struct comp_buffer {
    uint16 Width;
    uint16 Height;
    uint16 BytesPerPixel;
    void *PackedBuffer;
    void *UnpackedBuffer;
};

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 mask_point {
    v2 Pos;
    bool32 HandleBezier;
    bool32 IsSelected;
    v2 TangentLeft;
    v2 TangentRight;
};

struct mask {
    mask_point Point[16];
    bool32 IsClosed;
    uint16 NumberOfPoints;
    uint16 NumberOfSelectedPoints;
    void *TriangulatedPointCache;
    uint32 NumberOfVerts;
};


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,
    selection_maskpoint,
    selection_source
};

char *ToolName[] {
    "Move",
    "Pen"
};

enum tool {
    tool_default,
    tool_pen,
    tool_count
};

struct pen_state {
    bool32 IsActive;
};

enum interact_type
{
    interact_type_keyframe_move,
    interact_type_keyframe_rotate,
    interact_type_keyframe_scale
}


struct brush_tool
{
      real32 Size;
      real32 Opacity;
      real32 Hardness;
};

enum focused_window
{
    focus_viewport,
    focus_properties,
    focus_timeline
};

struct ui_graph {
    property_channel *ChannelViewed;
    real32 WindowYOffset = 300;
    real32 UpperVal;
    real32 LowerVal;
    uint16 GraphWindowHeight;     // The size of the window enclosing the graph
};

struct ui
{
    real32 TimelineSplit = 600;
    real32 GraphPropsSplit = 200;
    real32 TimelineZoom;
    real32 GraphZoom = 30;

    // Under 1 is zoomed in!
    real32 TimelinePercentZoomed = 1.0f;
    real32 TimelinePercentOffset = 0.3f;

    real32 Default_Y_TimelinePercentZoomed = 1.2f;
    real32 Default_Y_TimelinePercentOffset = 0.0f;

    real32 Y_TimelinePercentZoomed;
    real32 Y_TimelinePercentOffset;

    bool32 IsDragging;
    bool32 IsTransforming;
    int32 Wrap_X = 0;
    int32 Wrap_Y = 0;
    real32 TempVal;
    real32 TempVal_X;
    real32 OldVal[4];

    real32 Y_MaxVal;
    real32 Y_MinVal;

    real32 Display_Y_MaxVal;
    real32 Display_Y_MinVal;

    bool32 WantSetPos = false;
    ImVec2 SetPos;
    real32 InitPos;
    int32 WrapDirection;

    // Note that I don't use "zoom" to mean the scale in relation to the
    // original (i.e. default = 1.0f); it's the literal screen size in pixels
    // of the composition in the UI.
    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;

    // Custom scrolling for the timeline, as ImGui's didn't work well
    real32 G_ScrollXOffset;
    real32 G_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 DraggingEffectThreshold;
    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.

    ui_graph Graph[4];
    uint16 NumberOfGraphsEnabled;

    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;     // Signed as a shortcut for invalid on -1
    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;
};

#endif