hello, i have downloaded this on my computer some time ago and at the time of downloading this and testing it out, i decided to uninstall this software due to it crashing as other softwares do when there is to much space or too much happening and such. now, wanting to see how things go this time around i downloaded this software recently and it doesn’t show anything when opening it. it does show the black mouse and the other black mouse types such as a {black “resize window” mouse} and so on but no screen; no user interface i think it may be called for lack of terms. my computer screen background is visible when it is not supposed to be. it is the software that is supposed to be visible with a welcoming screen and showing the links to start a new project but it is not visible even if i click around on the screen to get something to show.
I can’t do anything about this if I can’t reproduce it, so you’d have to provide details about your system and possibly the log file and/or a crash dump. See Reporting Bugs - Zrythm 1.0.0-rc.1 documentation
i think maybe a new version of this software may be a fix. i saw that the current version was done in April. still, i did some thinking and i feel that what may be a solution is if this software can be completely wiped from recognizing my computer system. when i get a vst or another software, usually the software or vst is registered to the computer that it was used on; such as a license key type function embedded to the computer. i think that this may be what happened to my computer in this situation. even though i uninstalled all of the files to my understanding, i think that each time i download this software again that it is still recognizing that my computer had this software before and not that it is a completely new computer. so, i ask; how do you unregister this software completely from my computer so when i download this software again, it would open up on my computer as if it was a new computer that hasn’t downloaded this software from before?
something that i noticed that seems extra to me; i dont see the minimum system requirements to run this software. my computer may not have the minimum requirements to run this current version. i decided to mention this too just in case. dell latitude, e5440, windows 10 pro, 64, 8ram already with 8ram added which was separate.
still, how do you unregister this software completely from my computer so when i download this software again, it would open up on my computer as if it was a new computer that hasn’t downloaded this software from before?
1841| rect_coverage (Rect r,
1842| vec2 p,
1843| vec2 dFdp)
1844| {
1845| Rect prect = Rect(vec4(p - 0.5 * dFdp, p + 0.5 * dFdp));
1846| Rect coverect = rect_intersect (r, prect);
1847| vec2 coverage = rect_size(coverect) / dFdp;
1848| return coverage.x * coverage.y;
1849| }
1850|
1851| float
1852| rect_coverage (Rect r, vec2 p)
1853| {
1854| return rect_coverage (r, p, abs (fwidth (p)));
1855| }
1856|
1857|
1858| #endif
1859|
1860| #endif
1861| #ifndef _ROUNDED_RECT_
1862| #define _ROUNDED_RECT_
1863|
1864| #ifndef _ELLIPSE_
1865| #define _ELLIPSE_
1866|
1867| struct Ellipse
1868| {
1869| vec2 center;
1870| vec2 radius;
1871| };
1872|
1873| float
1874| ellipse_distance (Ellipse r, vec2 p)
1875| {
1876| vec2 e = r.radius;
1877| p = p - r.center;
1878|
1879| if (e.x == e.y)
1880| return length (p) - e.x;
1881|
1882| /* from https://www.shadertoy.com/view/tt3yz7 */
1883| vec2 pAbs = abs(p);
1884| vec2 ei = 1.0 / e;
1885| vec2 e2 = e*e;
1886| vec2 ve = ei * vec2(e2.x - e2.y, e2.y - e2.x);
1887|
1888| vec2 t = vec2(0.70710678118654752, 0.70710678118654752);
1889| for (int i = 0; i < 3; i++) {
1890| vec2 v = ve*t*t*t;
1891| vec2 u = normalize(pAbs - v) * length(t * e - v);
1892| vec2 w = ei * (v + u);
1893| t = normalize(clamp(w, 0.0, 1.0));
1894| }
1895|
1896| vec2 nearestAbs = t * e;
1897| float dist = length(pAbs - nearestAbs);
1898| return dot(pAbs, pAbs) < dot(nearestAbs, nearestAbs) ? -dist : dist;
1899| }
1900|
1901| #endif
1902|
1903| struct RoundedRect
1904| {
1905| vec4 bounds;
1906| vec4 corner_widths;
1907| vec4 corner_heights;
1908| };
1909|
1910| RoundedRect
1911| rounded_rect_from_rect (Rect r)
1912| {
1913| return RoundedRect (r.bounds, vec4 (0.0), vec4 (0.0));
1914| }
1915|
1916| RoundedRect
1917| rounded_rect_from_gsk (mat3x4 gsk_rounded_rect)
1918| {
1919| return RoundedRect ((gsk_rounded_rect[0].xyxy + vec4 (0.0, 0.0, gsk_rounded_rect[0].zw)) * GSK_GLOBAL_SCALE.xyxy,
1920| gsk_rounded_rect[1] * GSK_GLOBAL_SCALE.xxxx,
1921| gsk_rounded_rect[2] * GSK_GLOBAL_SCALE.yyyy);
1922| }
1923|
1924| float
1925| rounded_rect_distance (RoundedRect r, vec2 p)
1926| {
1927| Rect bounds = Rect(vec4(r.bounds));
1928|
1929| float bounds_distance = rect_distance (bounds, p);
1930|
1931| Ellipse tl = Ellipse (r.bounds.xy + vec2( r.corner_widths.x, r.corner_heights.x),
1932| vec2(r.corner_widths.x, r.corner_heights.x));
1933| Ellipse tr = Ellipse (r.bounds.zy + vec2(-r.corner_widths.y, r.corner_heights.y),
1934| vec2(r.corner_widths.y, r.corner_heights.y));
1935| Ellipse br = Ellipse (r.bounds.zw + vec2(-r.corner_widths.z, -r.corner_heights.z),
1936| vec2(r.corner_widths.z, r.corner_heights.z));
1937| Ellipse bl = Ellipse (r.bounds.xw + vec2( r.corner_widths.w, -r.corner_heights.w),
1938| vec2(r.corner_widths.w, r.corner_heights.w));
1939|
1940| vec4 distances = vec4(ellipse_distance (tl, p),
1941| ellipse_distance (tr, p),
1942| ellipse_distance (br, p),
1943| ellipse_distance (bl, p));
1944|
1945| bvec4 is_out = bvec4(p.x < tl.center.x && p.y < tl.center.y,
1946| p.x > tr.center.x && p.y < tr.center.y,
1947| p.x > br.center.x && p.y > br.center.y,
1948| p.x < bl.center.x && p.y > bl.center.y);
1949| distances = mix (vec4(bounds_distance), distances, is_out);
1950|
1951| vec2 max2 = max (distances.xy, distances.zw);
1952| return max (max2.x, max2.y);
1953| }
1954|
1955| RoundedRect
1956| rounded_rect_shrink (RoundedRect r, vec4 amount)
1957| {
1958| vec4 new_bounds = r.bounds + vec4(1.0,1.0,-1.0,-1.0) * amount.wxyz;
1959| vec4 new_widths = max (r.corner_widths - sign (r.corner_widths) * amount.wyyw, 0.0);
1960| vec4 new_heights = max (r.corner_heights - sign (r.corner_heights) * amount.xxzz, 0.0);
1961| new_widths = min (new_widths, new_bounds.z - new_bounds.x);
1962| new_heights = min (new_heights, new_bounds.w - new_bounds.y);
1963|
1964| return RoundedRect (new_bounds, new_widths, new_heights);
1965| }
1966|
1967| void
1968| rounded_rect_scale (inout RoundedRect r,
1969| vec2 scale)
1970| {
1971| r.bounds *= scale.xyxy;
1972| r.corner_widths *= scale.xxxx;
1973| r.corner_heights *= scale.yyyy;
1974| }
1975|
1976| void
1977| rounded_rect_offset (inout RoundedRect r,
1978| vec2 offset)
1979| {
1980| r.bounds += offset.xyxy;
1981| }
1982|
1983| bool
1984| rounded_rect_is_slicable (RoundedRect r)
1985| {
1986| vec2 size = rect_size (Rect (r.bounds));
1987| return (r.corner_widths[TOP_LEFT] + r.corner_widths[BOTTOM_RIGHT] <= size.x ||
1988| r.corner_heights[TOP_LEFT] + r.corner_heights[BOTTOM_RIGHT] <= size.y)
1989| && (r.corner_widths[BOTTOM_LEFT] + r.corner_widths[TOP_RIGHT] <= size.x ||
1990| r.corner_heights[BOTTOM_LEFT] + r.corner_heights[TOP_RIGHT] <= size.y);
1991| }
1992|
1993| Rect
1994| rounded_rect_intersection_fallback_slice (RoundedRect outside,
1995| RoundedRect inside,
1996| uint slice)
1997| {
1998| switch (slice)
1999| {
2000| default:
2001| case SLICE_TOP:
2002| case SLICE_RIGHT:
2003| case SLICE_BOTTOM:
2004| case SLICE_LEFT:
2005| return Rect (vec4 (0.0));
2006|
2007| case SLICE_TOP_LEFT:
2008| return Rect (vec4 (outside.bounds.xy, 0.5 * (outside.bounds.xy + outside.bounds.zw)));
2009|
2010| case SLICE_TOP_RIGHT:
2011| return Rect (vec4 (0.5 * (outside.bounds.x + outside.bounds.z), outside.bounds.y,
2012| outside.bounds.z, 0.5 * (outside.bounds.y + outside.bounds.w)));
2013|
2014| case SLICE_BOTTOM_RIGHT:
2015| return Rect (vec4 (0.5 * (outside.bounds.xy + outside.bounds.zw), outside.bounds.zw));
2016|
2017| case SLICE_BOTTOM_LEFT:
2018| return Rect (vec4 (outside.bounds.x, 0.5 * (outside.bounds.y + outside.bounds.w),
2019| 0.5 * (outside.bounds.x + outside.bounds.z), outside.bounds.w));
2020| }
2021| }
2022|
2023| Rect
2024| rounded_rect_intersection_slice (RoundedRect outside,
2025| RoundedRect inside,
2026| uint slice)
2027| {
2028| float left, right, top, bottom;
2029|
2030| if (!rounded_rect_is_slicable (outside) ||
2031| !rounded_rect_is_slicable (inside))
2032| return rounded_rect_intersection_fallback_slice (outside, inside, slice);
2033|
2034| switch (slice)
2035| {
2036| case SLICE_TOP_LEFT:
2037| return Rect (vec4 (outside.bounds.x,
2038| outside.bounds.y,
2039| max (outside.bounds.x + outside.corner_widths[TOP_LEFT],
2040| inside.bounds.x + inside.corner_widths[TOP_LEFT]),
2041| max (outside.bounds.y + outside.corner_heights[TOP_LEFT],
2042| inside.bounds.y + inside.corner_heights[TOP_LEFT])));
2043|
2044| case SLICE_TOP:
2045| left = max (outside.bounds.x + outside.corner_widths[TOP_LEFT],
2046| inside.bounds.x + inside.corner_widths[TOP_LEFT]);
2047| right = min (outside.bounds.z - outside.corner_widths[TOP_RIGHT],
2048| inside.bounds.z - inside.corner_widths[TOP_RIGHT]);
2049| return Rect (vec4 (left,
2050| outside.bounds.y,
2051| max (left, right),
2052| max (outside.bounds.y, inside.bounds.y)));
2053|
2054| case SLICE_TOP_RIGHT:
2055| left = max (min (outside.bounds.z - outside.corner_widths[TOP_RIGHT],
2056| inside.bounds.z - inside.corner_widths[TOP_RIGHT]),
2057| max (outside.bounds.x + outside.corner_widths[TOP_LEFT],
2058| inside.bounds.x + inside.corner_widths[TOP_LEFT]));
2059| return Rect (vec4 (left,
2060| outside.bounds.y,
2061| outside.bounds.z,
2062| max (outside.bounds.y + outside.corner_heights[TOP_RIGHT],
2063| inside.bounds.y + inside.corner_heights[TOP_RIGHT])));
2064|
2065| case SLICE_RIGHT:
2066| top = max (outside.bounds.y + outside.corner_heights[TOP_RIGHT],
2067| inside.bounds.y + inside.corner_heights[TOP_RIGHT]);
2068| bottom = min (outside.bounds.w - outside.corner_heights[BOTTOM_RIGHT],
2069| inside.bounds.w - inside.corner_heights[BOTTOM_RIGHT]);
2070| return Rect (vec4 (min (outside.bounds.z, inside.bounds.z),
2071| top,
2072| outside.bounds.z,
2073| max (bottom, top)));
2074|
2075| case SLICE_BOTTOM_RIGHT:
2076| left = max (min (outside.bounds.z - outside.corner_widths[BOTTOM_RIGHT],
2077| inside.bounds.z - inside.corner_widths[BOTTOM_RIGHT]),
2078| max (outside.bounds.x + outside.corner_widths[BOTTOM_LEFT],
2079| inside.bounds.x + inside.corner_widths[BOTTOM_LEFT]));
2080| bottom = max (min (outside.bounds.w - outside.corner_heights[BOTTOM_RIGHT],
2081| inside.bounds.w - inside.corner_heights[BOTTOM_RIGHT]),
2082| max (outside.bounds.y + outside.corner_heights[TOP_RIGHT],
2083| inside.bounds.y + inside.corner_heights[TOP_RIGHT]));
2084| return Rect (vec4 (left,
2085| bottom,
2086| outside.bounds.z,
2087| outside.bounds.w));
2088|
2089| case SLICE_BOTTOM:
2090| left = max (outside.bounds.x + outside.corner_widths[BOTTOM_LEFT],
2091| inside.bounds.x + inside.corner_widths[BOTTOM_LEFT]);
2092| right = min (outside.bounds.z - outside.corner_widths[BOTTOM_RIGHT],
2093| inside.bounds.z - inside.corner_widths[BOTTOM_RIGHT]);
2094| return Rect (vec4 (left,
2095| min (outside.bounds.w, inside.bounds.w),
2096| max (left, right),
2097| outside.bounds.w));
2098|
2099| case SLICE_BOTTOM_LEFT:
2100| bottom = max (min (outside.bounds.w - outside.corner_heights[BOTTOM_LEFT],
2101| inside.bounds.w - inside.corner_heights[BOTTOM_LEFT]),
2102| max (outside.bounds.y + outside.corner_heights[TOP_LEFT],
2103| inside.bounds.y + inside.corner_heights[TOP_LEFT]));
2104| return Rect (vec4 (outside.bounds.x,
2105| bottom,
2106| max (outside.bounds.x + outside.corner_widths[BOTTOM_LEFT],
2107| inside.bounds.x + inside.corner_widths[BOTTOM_LEFT]),
2108| outside.bounds.w));
2109|
2110| case SLICE_LEFT:
2111| top = max (outside.bounds.y + outside.corner_heights[TOP_LEFT],
2112| inside.bounds.y + inside.corner_heights[TOP_LEFT]);
2113| bottom = min (outside.bounds.w - outside.corner_heights[BOTTOM_LEFT],
2114| inside.bounds.w - inside.corner_heights[BOTTOM_LEFT]);
2115| return Rect (vec4 (outside.bounds.x,
2116| top,
2117| max (outside.bounds.x, inside.bounds.x),
2118| max (bottom, top)));
2119|
2120| default:
2121| return Rect (vec4 (0.0));
2122| }
2123| }
2124|
2125| #ifdef GSK_FRAGMENT_SHADER
2126|
2127| float
2128| rounded_rect_coverage (RoundedRect r, vec2 p)
2129| {
2130| vec2 fw = abs (fwidth (p));
2131| float distance_scale = max (fw.x, fw.y);
2132| float distance = rounded_rect_distance (r, p) / distance_scale;
2133| float coverage = 0.5 - distance;
2134|
2135| return clamp (coverage, 0.0, 1.0);
2136| }
2137|
2138| #endif
2139|
2140| #endif
2141|
2142| #define PI 3.1415926535897932384626433832795
2143| #define SQRT1_2 1.4142135623730951
2144|
2145| Rect
2146| rect_clip (Rect r)
2147| {
2148| if (GSK_SHADER_CLIP == GSK_GPU_SHADER_CLIP_NONE)
2149| return r;
2150| else
2151| return rect_intersect (r, rect_from_gsk (GSK_GLOBAL_CLIP_RECT));
2152| }
2153|
2154| #ifdef GSK_VERTEX_SHADER
2155|
2156| const vec2 offsets[6] = vec2[6](vec2(0.0, 0.0),
2157| vec2(1.0, 0.0),
2158| vec2(0.0, 1.0),
2159| vec2(0.0, 1.0),
2160| vec2(1.0, 0.0),
2161| vec2(1.0, 1.0));
2162|
2163| void
2164| gsk_set_position (vec2 pos)
2165| {
2166| gl_Position = GSK_GLOBAL_MVP * vec4 (pos, 0.0, 1.0);
2167| }
2168|
2169| vec2
2170| rect_get_position (Rect rect)
2171| {
2172| Rect r = rect_round_larger (rect_clip (rect));
2173|
2174| vec2 pos = mix (r.bounds.xy, r.bounds.zw, offsets[GSK_VERTEX_INDEX]);
2175|
2176| return pos;
2177| }
2178|
2179| vec2
2180| border_get_position (RoundedRect outside,
2181| RoundedRect inside)
2182| {
2183| uint slice_index = uint (GSK_VERTEX_INDEX) / 6u;
2184| uint vert_index = uint (GSK_VERTEX_INDEX) % 6u;
2185|
2186| Rect rect = rounded_rect_intersection_slice (outside, inside, slice_index);
2187|
2188| switch (slice_index)
2189| {
2190| case SLICE_TOP_LEFT:
2191| rect = rect_round_larger (rect);
2192| rect.bounds = rect.bounds.xwzy;
2193| break;
2194| case SLICE_TOP:
2195| rect = rect_round_smaller_larger (rect);
2196| break;
2197| case SLICE_TOP_RIGHT:
2198| rect = rect_round_larger (rect);
2199| break;
2200| case SLICE_RIGHT:
2201| rect = rect_round_larger_smaller (rect);
2202| break;
2203| case SLICE_BOTTOM_RIGHT:
2204| rect = rect_round_larger (rect);
2205| rect.bounds = rect.bounds.zyxw;
2206| break;
2207| case SLICE_BOTTOM:
2208| rect = rect_round_smaller_larger (rect);
2209| break;
2210| case SLICE_BOTTOM_LEFT:
2211| rect = rect_round_larger (rect);
2212| rect.bounds = rect.bounds.zwxy;
2213| break;
2214| case SLICE_LEFT:
2215| rect = rect_round_larger_smaller (rect);
2216| break;
2217| }
2218|
2219| vec2 pos = mix (rect.bounds.xy, rect.bounds.zw, offsets[vert_index]);
2220|
2221| return pos;
2222| }
2223|
2224| vec2
2225| scale_tex_coord (vec2 in_pos,
2226| Rect in_rect,
2227| vec4 tex_rect)
2228| {
2229| return tex_rect.xy + (in_pos - in_rect.bounds.xy) / rect_size (in_rect) * tex_rect.zw;
2230| }
2231|
2232| void run (out vec2 pos);
2233|
2234| void
2235| main (void)
2236| {
2237| vec2 pos;
2238|
2239| run (pos);
2240|
2241| gsk_set_position (pos);
2242| }
2243|
2244| #endif /* GSK_VERTEX_SHADER */
2245|
2246|
2247| #ifdef GSK_FRAGMENT_SHADER
2248|
2249| vec4
2250| gsk_texture_straight_alpha (uint tex_id,
2251| vec2 pos)
2252| {
2253| vec2 size = vec2 (gsk_texture_size (tex_id, 0));
2254| pos *= size;
2255| size -= vec2 (1.0);
2256| /* GL_CLAMP_TO_EDGE */
2257| pos = clamp (pos - 0.5, vec2 (0.0), size);
2258| ivec2 ipos = ivec2 (pos);
2259| pos = fract (pos);
2260| vec4 tl = gsk_texel_fetch (tex_id, ipos, 0);
2261| tl.rgb *= tl.a;
2262| vec4 tr = gsk_texel_fetch (tex_id, ipos + ivec2(1, 0), 0);
2263| tr.rgb *= tr.a;
2264| vec4 bl = gsk_texel_fetch (tex_id, ipos + ivec2(0, 1), 0);
2265| bl.rgb *= bl.a;
2266| vec4 br = gsk_texel_fetch (tex_id, ipos + ivec2(1, 1), 0);
2267| br.rgb *= br.a;
2268| return mix (mix (tl, tr, pos.x), mix (bl, br, pos.x), pos.y);
2269| }
2270|
2271| void run (out vec4 color,
2272| out vec2 pos);
2273|
2274| void
2275| main_clip_none (void)
2276| {
2277| vec4 color;
2278| vec2 pos;
2279|
2280| run (color, pos);
2281|
2282| gsk_set_output_color (color);
2283| }
2284|
2285| void
2286| main_clip_rect (void)
2287| {
2288| vec4 color;
2289| vec2 pos;
2290|
2291| run (color, pos);
2292|
2293| Rect clip = rect_from_gsk (GSK_GLOBAL_CLIP_RECT);
2294|
2295| float coverage = rect_coverage (clip, pos);
2296| color *= coverage;
2297|
2298| gsk_set_output_color (color);
2299| }
2300|
2301| void
2302| main_clip_rounded (void)
2303| {
2304| vec4 color;
2305| vec2 pos;
2306|
2307| run (color, pos);
2308|
2309| RoundedRect clip = rounded_rect_from_gsk (GSK_GLOBAL_CLIP);
2310|
2311| float coverage = rounded_rect_coverage (clip, pos);
2312| color *= coverage;
2313|
2314| gsk_set_output_color (color);
2315| }
2316|
2317| void
2318| main (void)
2319| {
2320| if (GSK_SHADER_CLIP == GSK_GPU_SHADER_CLIP_NONE)
2321| main_clip_none ();
2322| else if (GSK_SHADER_CLIP == GSK_GPU_SHADER_CLIP_RECT)
2323| main_clip_rect ();
2324| else if (GSK_SHADER_CLIP == GSK_GPU_SHADER_CLIP_ROUNDED)
2325| main_clip_rounded ();
2326| }
2327|
2328| #endif /* GSK_FRAGMENT_SHADER */
2329|
2330| #endif
2331|
2332|
2333| PASS_FLAT(0) mat4 _color_matrix;
2334| PASS_FLAT(4) vec4 _color_offset;
2335| PASS(5) vec2 _pos;
2336| PASS_FLAT(6) Rect _rect;
2337| PASS(7) vec2 _tex_coord;
2338| PASS_FLAT(8) uint _tex_id;
2339|
2340|
2341| #ifdef GSK_VERTEX_SHADER
2342|
2343| IN(0) mat4 in_color_matrix;
2344| IN(4) vec4 in_color_offset;
2345| IN(5) vec4 in_rect;
2346| IN(6) vec4 in_tex_rect;
2347| IN(7) uint in_tex_id;
2348|
2349| void
2350| run (out vec2 pos)
2351| {
2352| Rect r = rect_from_gsk (in_rect);
2353|
2354| pos = rect_get_position (r);
2355|
2356| _pos = pos;
2357| _rect = r;
2358| _tex_coord = rect_get_coord (rect_from_gsk (in_tex_rect), pos);
2359| _tex_id = in_tex_id;
2360| _color_matrix = in_color_matrix;
2361| _color_offset = in_color_offset;
2362| }
2363|
2364| #endif
2365|
2366|
2367|
2368| #ifdef GSK_FRAGMENT_SHADER
2369|
2370| void
2371| run (out vec4 color,
2372| out vec2 position)
2373| {
2374| #if 0
2375| vec4 pixel = gsk_texture_straight_alpha (_tex_id, _tex_coord);
2376| #else
2377| vec4 pixel = gsk_texture (_tex_id, _tex_coord);
2378| pixel = color_unpremultiply (pixel);
2379| #endif
2380| pixel = _color_matrix * pixel + _color_offset;
2381| pixel = clamp (pixel, 0.0, 1.0);
2382|
2383| color = color_premultiply (pixel) * rect_coverage (_rect, _pos);
2384| position = _pos;
2385| }
2386|
2387| #endif
2388|
Error Message:
(zrythm.exe:10124): zrythm-DEBUG: 23:40:51.490: (on_close_request:375): close request
zrythm-Message: 23:40:51.637: (zrythm_app_on_shutdown:1246): Shutting down...
zrythm-Message: 23:40:51.637: (zrythm_free:655): zrythm_free: deleting Zrythm instance...
zrythm-Message: 23:40:51.637: (recording_manager_free:1513): recording_manager_free: Freeing...
zrythm-Message: 23:40:51.895: (recording_manager_free:1533): recording_manager_free: done
(zrythm.exe:10124): zrythm-DEBUG: 23:40:51.895: (plugin_manager_free:927): plugin_manager_free: Freeing...
(zrythm.exe:10124): zrythm-DEBUG: 23:40:51.895: (plugin_manager_free:939): plugin_manager_free: done
zrythm-Message: 23:40:51.895: (event_manager_free:1370): event_manager_free: Freeing...
zrythm-Message: 23:40:51.896: (event_manager_free:1380): event_manager_free: done
zrythm-Message: 23:40:51.898: (zrythm_free:683): zrythm_free: done
zrythm-Message: 23:40:51.898: (zrythm_app_on_shutdown:1264): done
zrythm-Message: 23:40:57.919: (segv_handler:144): Error - Backtrace:
17: backtrace_get - 0x69506110
16: zrythm_app_get_type - 0x694116D0
15: peak_dsp_free - 0x69645670
14: _C_specific_handler - 0xDA83CDC0
13: _chkstk - 0xDA852810
12: RtlRaiseException - 0xDA8020D0
11: KiUserExceptionDispatcher - 0xDA851410
10: z_carla_discovery_idle - 0x6953A000
9: plugin_manager_add_descriptor - 0x694D9ED0
8: g_clear_list - 0xA789F2A0
7: g_get_monotonic_time - 0xA78A2800
6: g_main_context_iteration - 0xA78A3980
5: g_application_run - 0xA6508020
4: main - 0x6978A480
3: main - 0x6978A480
2: main - 0x6978A480
1: BaseThreadInitThunk - 0xD9677360
0: RtlUserThreadStart - 0xDA7FCC70
This seems like a bug on the GTK side, it errors out while compiling its shaders. Maybe it will be fixed if I use a newer release. Will update GTK in the next release - hopefully they’ve fixed this by then.