2ba707e0d03c83739c65451ee9a4ddbb5e18b784
2 * Copyright 2021-2022 (C) Mount0 Software, Harry Godden - All Rights Reserved
3 * -----------------------------------------------------------------------------
7 * -----------------------------------------------------------------------------
15 static struct vg_loader
18 vg_semaphore sem_loading
;
23 k_loader_status_loading
,
24 k_loader_status_complete
,
30 struct loader_free_step
32 void (*fn_free
)(void *);
36 u32 step_count
, step_cap
, step_action
;
40 static int vg_loader_init(void)
42 vg_semaphore_init( &vg_loader
.sem_loading
, 0 );
43 vg_mutex_init( &vg_loader
.mux_status
);
47 static void vg_loader_free(void)
49 vg_semaphore_wait( &vg_loader
.sem_loading
);
50 vg_semaphore_free( &vg_loader
.sem_loading
);
51 vg_mutex_free( &vg_loader
.mux_status
);
53 for( int i
=0; i
<vg_loader
.step_count
; i
++ )
55 struct loader_free_step
*step
=
56 &vg_loader
.step_buffer
[vg_loader
.step_count
-1 -i
];
58 step
->fn_free( step
->data
);
61 free( vg_loader
.step_buffer
);
64 static enum loader_status
vg_loader_status(void)
66 enum loader_status answer
;
68 vg_mutex_lock( &vg_loader
.mux_status
);
69 answer
= vg_loader
.status
;
70 vg_mutex_unlock( &vg_loader
.mux_status
);
75 static float hue_to_rgb( float p
, float q
, float t
)
77 if(t
< 0.0f
) t
+= 1.0f
;
78 if(t
> 1.0f
) t
-= 1.0f
;
79 if(t
< 1.0f
/6.0f
) return p
+ (q
- p
) * 6.0f
* t
;
80 if(t
< 1.0f
/2.0f
) return q
;
81 if(t
< 2.0f
/3.0f
) return p
+ (q
- p
) * (2.0f
/3.0f
- t
) * 6.0f
;
85 static void vg_loader_render(void)
87 float h
= vg_fractf(vg_time
*0.1),
89 l
= 0.1f
, //* (0.5f+vg_fractf(vg_time*40.0)*0.5f),
90 q
= l
< 0.5f
? l
* (1.0f
+ s
) : l
+ s
- l
* s
,
92 r
= hue_to_rgb( p
, q
, h
+ 1.0f
/3.0f
),
93 g
= hue_to_rgb( p
, q
, h
),
94 b
= hue_to_rgb( p
, q
, h
- 1.0f
/3.0f
);
96 glClearColor( r
, g
, b
, 1.0f
);
97 glClear( GL_COLOR_BUFFER_BIT
|GL_DEPTH_BUFFER_BIT
);
101 ui_begin( &ui_global_ctx
, vg_window_x
, vg_window_y
);
105 int lines_screen_max
= ((vg_window_y
/fh
)-2),
106 lines_max_draw
= VG_MIN( lines_screen_max
, vg_list_size(vg_log
.buffer
) ),
107 lines_to_draw
= VG_MIN( lines_max_draw
, vg_log
.buffer_line_count
);
109 int ptr
= vg_log
.buffer_line_current
;
111 ui_global_ctx
.cursor
[0] = 0;
112 ui_global_ctx
.cursor
[1] = lines_to_draw
*fh
;
113 ui_global_ctx
.cursor
[3] = fh
;
114 ui_fill_x( &ui_global_ctx
);
116 for( int i
=0; i
<lines_to_draw
; i
++ )
121 ptr
= vg_list_size( vg_log
.buffer
)-1;
123 ui_text( &ui_global_ctx
, ui_global_ctx
.cursor
,
124 vg_log
.buffer
[ptr
], vg_console
.scale
, 0 );
126 ui_global_ctx
.cursor
[1] -= fh
*vg_console
.scale
;
129 ui_resolve( &ui_global_ctx
);
130 ui_draw( &ui_global_ctx
, NULL
);
134 static int vg_load_full(void);
136 static void vg_loader_thread(void * nothing
)
138 /* Run client loader */
139 int res
= vg_load_full();
141 /* Propogate status */
142 vg_mutex_lock( &vg_loader
.mux_status
);
145 vg_loader
.status
= k_loader_status_complete
;
149 vg_loader
.status
= k_loader_status_fail
;
151 vg_mutex_unlock( &vg_loader
.mux_status
);
153 vg_semaphore_post( &vg_loader
.sem_loading
);
156 static void vg_loader_start(void)
158 vg_thread_run( vg_loader_thread
, NULL
);
161 static void vg_free_libc_malloced( void *data
)
166 static int vg_loader_push_free_step( struct loader_free_step step
)
168 void *buf
= buffer_reserve( vg_loader
.step_buffer
, vg_loader
.step_count
,
169 &vg_loader
.step_cap
, 1,
170 sizeof( struct loader_free_step
) );
175 vg_loader
.step_buffer
= buf
;
176 vg_loader
.step_buffer
[ vg_loader
.step_count
++ ] = step
;
180 * Schedule something to be freed
182 __attribute__((warn_unused_result
))
183 static int vg_loader_highwater( void( *fn_free
)(void *), void *data
)
187 struct loader_free_step step
;
189 step
.fn_free
= fn_free
;
191 if( !vg_loader_push_free_step( step
) )
198 struct loader_free_step step
;
200 step
.fn_free
= vg_free_libc_malloced
;
202 if( !vg_loader_push_free_step( step
) )
207 vg_mutex_lock( &vg
.mux_engine_status
);
209 if( !vg
.engine_running
)
211 vg_mutex_unlock( &vg
.mux_engine_status
);
215 vg_mutex_unlock( &vg
.mux_engine_status
);
219 #endif /* VG_LOADER_H */
233 int (*fn_load
)(void);
234 void (*fn_free
)(void);
240 u32 step_count
, step_cap
, step_action
,
241 low_water_mark
; /* What is the minumum number of systems we can have? */
245 k_loader_status_loading
,
246 k_loader_status_complete
,
255 static void loader_add_stage( struct loader_step step
)
257 loader
.step_buffer
= buffer_reserve( loader
.step_buffer
, loader
.step_count
,
259 1, sizeof( struct loader_step
) );
261 loader
.step_buffer
[ loader
.step_count
++ ] = step
;
264 static void loader_insert_stage( struct loader_step step
)
269 static void loader_cancel(void)
271 MUTEX_LOCK( loader
.mux
);
273 MUTEX_UNLOCK( loader
.mux
);
276 static void loader_worker_thread( void *nothing
)
280 vg_sleep_ms( 1000.0 );
281 vg_info( "... loader ....\n" );
290 static void loader_begin(void)
292 if( loader
.step_count
== 0 )
294 loader
.status
= k_loader_status_complete
;
298 loader
.status
= k_loader_status_loading
;
299 vg_thread_run( loader_worker_thread
, NULL
);
302 static void loader_free(void)
305 for( int i
=0; i
<loader
.step_count
; i
++ )
307 struct loader_step
*step
= &loader
.step_buffer
[ loader
.step_count
-i
-1 ];
314 * Returns 0 if loading is not happening
315 * Returns 1 if we are loading something
317 static int loader_update(void)
319 MUTEX_LOCK( loader
.mux
);
321 if( loader
.status
== k_loader_status_complete
)
323 MUTEX_UNLOCK( loader
.mux
);
328 struct loader_step
*cstep
= &loader
.step_buffer
[ loader
.step_action
];
330 if( cstep
->require_opengl
)
332 if( !cstep
->fn_load() )
335 MUTEX_UNLOCK( loader
.mux
);
341 loader
.step_action
++;
344 MUTEX_UNLOCK( loader
.mux
);
349 #endif /* LOADER_H */