AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-11-09 10:20:07 +00:00
Code Issues Projects Releases Wiki Activity
main
gtk/gsk/meson.build

260 lines
6.4 KiB
Meson
Raw Permalink Normal View History

Rename ngl to gl We have only one gl renderer now, and it is a bit odd for it not be called gl.
2021-10-07 03:15:25 +00:00
gsk_private_gl_shaders = [
'gl/resources/preamble.glsl',
'gl/resources/preamble.fs.glsl',
'gl/resources/preamble.vs.glsl',
'gl/resources/border.glsl',
'gl/resources/blit.glsl',
'gl/resources/coloring.glsl',
'gl/resources/color.glsl',
'gl/resources/linear_gradient.glsl',
'gl/resources/radial_gradient.glsl',
'gl/resources/conic_gradient.glsl',
'gl/resources/color_matrix.glsl',
'gl/resources/blur.glsl',
'gl/resources/inset_shadow.glsl',
'gl/resources/outset_shadow.glsl',
'gl/resources/unblurred_outset_shadow.glsl',
'gl/resources/cross_fade.glsl',
'gl/resources/blend.glsl',
'gl/resources/repeat.glsl',
'gl/resources/custom.glsl',
'gl/resources/filled_border.glsl',
gl: Support mask nodes Add a shader for masking.
2023-02-11 15:38:56 +00:00
'gl/resources/mask.glsl',
gsk: Add a shader for external textures This shader uses samplerExternalOES to sample an external texture and blit it into a 'normal' texture. It only works in GLES, but we won't use it outside of GLES.
2023-10-21 18:29:49 +00:00
'gl/resources/external.glsl',
gsk: Handle straight-alpha dmabufs This omission was noticed by Benjamin Otte. Add a premultiply uniform to the external shader, and add a separate premultiply shader for the non-external case.
2023-12-14 14:46:51 +00:00
'gl/resources/premultiply.glsl',
gsk: Give ngl its own shader sources We may want to change the interface between the shaders and the renderer for ngl, and therefore, sharing the shaders between gl and ngl will not be practical, going forward.
2021-03-12 02:31:31 +00:00
]
meson: update list of sources for changes in git master
2017-03-11 22:31:31 +00:00
gsk_public_sources = files([
gsk: Export Cairo renderer
2019-05-01 21:58:57 +00:00
'gskcairorenderer.c',
gsk: Add GskPath This commit adds the basic infrastructure for paths. The public APIs consists of GskPath, GskPathPoint and GskPathBuilder. GskPath is a data structure for paths that consists of contours, which in turn might contain Bézier curves. The Bezier data structure is inspired by Skia, with separate arrays for points and operations. One advantage of this arrangement is that start and end points are shared between adjacent curves. A GskPathPoint represents a point on a path, which can be queried for various properties. GskPathBuilder is an auxiliary builder object for paths.
2023-07-08 14:15:22 +00:00
'gskdiff.c',
Add GskGLShaderNode and GskGLShader A GskGLShader is an abstraction of a GLSL fragment shader that can produce pixel values given inputs: * N (currently max 4) textures * Current arguments for the shader uniform Uniform types are: float,(u)int,bool,vec234) There is also a builder for the uniform arguments which are passed around as immutable GBytes in the built form. A GskGLShaderNode is a render node that renders a GskGLShader inside a specified rectangular bounds. It renders its child nodes as textures and passes those as texture arguments to the shader. You also pass it a uniform arguments object.
2020-09-18 15:46:57 +00:00
'gskglshader.c',
gsk: Add code to offload to subsurfaces This code walks the node tree, finds subsurface nodes, determines if we can offload to the subsurface, and if yes, does so. This isn't used yet.
2023-11-09 19:07:15 +00:00
'gskoffload.c',
gsk: Add GskPath This commit adds the basic infrastructure for paths. The public APIs consists of GskPath, GskPathPoint and GskPathBuilder. GskPath is a data structure for paths that consists of contours, which in turn might contain Bézier curves. The Bezier data structure is inspired by Skia, with separate arrays for points and operations. One advantage of this arrangement is that start and end points are shared between adjacent curves. A GskPathPoint represents a point on a path, which can be queried for various properties. GskPathBuilder is an auxiliary builder object for paths.
2023-07-08 14:15:22 +00:00
'gskpath.c',
'gskpathbuilder.c',
Add GskPathMeasure GskPathMeasure is the public API for path lengths.
2023-08-13 15:08:22 +00:00
'gskpathmeasure.c',
path: Split off gskpathparse.c This is a standalone piece of code, and nicely fits into its own source file.
2023-09-17 16:29:46 +00:00
'gskpathparser.c',
gsk: Add GskPath This commit adds the basic infrastructure for paths. The public APIs consists of GskPath, GskPathPoint and GskPathBuilder. GskPath is a data structure for paths that consists of contours, which in turn might contain Bézier curves. The Bezier data structure is inspired by Skia, with separate arrays for points and operations. One advantage of this arrangement is that start and end points are shared between adjacent curves. A GskPathPoint represents a point on a path, which can be queried for various properties. GskPathBuilder is an auxiliary builder object for paths.
2023-07-08 14:15:22 +00:00
'gskpathpoint.c',
meson: update build files
2016-11-03 08:47:00 +00:00
'gskrenderer.c',
'gskrendernode.c',
meson: update list of sources for changes in git master
2017-03-11 22:31:31 +00:00
'gskrendernodeimpl.c',
testsuite: Redo node-parser Base the rewrite on testsuite/css/parser/test-css-parser - we now require the node file to match a reference node and track the errors it triggers. We also no longer use gtester.
2019-05-14 01:20:09 +00:00
'gskrendernodeparser.c',
transform: Move to GSK The renaming of the prefix makes this a large patch.
2019-02-28 08:52:49 +00:00
'gskroundedrect.c',
Add GskStroke A GskStroke struct collects the parameters that are needed for stroking a path.
2023-07-08 14:32:52 +00:00
'gskstroke.c',
transform: Move to GSK The renaming of the prefix makes this a large patch.
2019-02-28 08:52:49 +00:00
'gsktransform.c',
Rename ngl to gl We have only one gl renderer now, and it is a bit odd for it not be called gl.
2021-10-07 03:15:25 +00:00
'gl/gskglrenderer.c',
gsk: meson: Document renderers These contain docstrings.
2024-05-25 16:43:28 +00:00
'gpu/gsknglrenderer.c',
'gpu/gskvulkanrenderer.c',
meson: update list of sources for changes in git master
2017-03-11 22:31:31 +00:00
])
gsk_private_sources = files([
'gskcairoblur.c',
gsk: Add GskPath This commit adds the basic infrastructure for paths. The public APIs consists of GskPath, GskPathPoint and GskPathBuilder. GskPath is a data structure for paths that consists of contours, which in turn might contain Bézier curves. The Bezier data structure is inspired by Skia, with separate arrays for points and operations. One advantage of this arrangement is that start and end points are shared between adjacent curves. A GskPathPoint represents a point on a path, which can be queried for various properties. GskPathBuilder is an auxiliary builder object for paths.
2023-07-08 14:15:22 +00:00
'gskcontour.c',
'gskcurve.c',
meson: update build files
2016-11-03 08:47:00 +00:00
'gskdebug.c',
'gskprivate.c',
'gskprofiler.c',
Rename ngl to gl We have only one gl renderer now, and it is a bit odd for it not be called gl.
2021-10-07 03:15:25 +00:00
'gl/gskglattachmentstate.c',
'gl/gskglbuffer.c',
'gl/gskglcommandqueue.c',
'gl/gskglcompiler.c',
'gl/gskgldriver.c',
'gl/gskglglyphlibrary.c',
'gl/gskgliconlibrary.c',
'gl/gskglprogram.c',
'gl/gskglrenderjob.c',
'gl/gskglshadowlibrary.c',
'gl/gskgltexturelibrary.c',
'gl/gskgluniformstate.c',
'gl/gskgltexture.c',
'gl/gskglprofiler.c',
'gl/stb_rect_pack.c',
'gl/fp16.c',
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
'gpu/gskglbuffer.c',
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
'gpu/gskgldevice.c',
'gpu/gskglframe.c',
'gpu/gskglimage.c',
gpu: Make blend modes configurable For now, we only have OVER and ADD blend modes. This commit doesn't use ADD, it just sets up all the machinery and refactors things.
2023-12-25 04:21:13 +00:00
'gpu/gskgpublendop.c',
gpu: Add a blend mode shader I'm a bit unsure about using the zero rect in the fallback situtation where one image doesn't exist, but it seems to work. This removes the last pattern-only rendernode and with that the last fallback usage with disabled ubershader.
2023-12-31 06:16:09 +00:00
'gpu/gskgpublendmodeop.c',
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
'gpu/gskgpublitop.c',
gpu: Implement shadow nodes
2023-09-18 05:51:14 +00:00
'gpu/gskgpublurop.c',
gpu: Add a border shader Pretty much a copy of the Vulkan border shader. A notable change is that the input arguments are changed, because GL gets confused if you put a mat4 at the end.
2023-09-10 21:19:42 +00:00
'gpu/gskgpuborderop.c',
gpu: Add a box shadow shader Code was inspired mainly by https://madebyevan.com/shaders/fast-rounded-rectangle-shadows/ and https://pcwalton.github.io/_posts/2015-12-21-drawing-css-box-shadows-in-webrender.html So far the results aren't cached, that's the task of future commits.
2023-10-08 04:47:19 +00:00
'gpu/gskgpuboxshadowop.c',
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
'gpu/gskgpubuffer.c',
gpu: Split cache and device This is for 3 reasons: 1. Separation of concerns The device is meant to manage the Vulkan/GL device and check stuff like image sizes. Caching is not part of that. 2. Refcounting Images etc want to reference the device, but the cache wants to reference images. If the cache is the device, that's a refcycle. 3. Flexibility It's now easier to implement >1 cache, say one per depth or one per color state.
2024-07-03 02:04:32 +00:00
'gpu/gskgpucache.c',
gpu: Copy the clear trick from the Vulkan shader When drawing opaque color regions that are large enough, use vkCmdClearAttachments()/glClear() instead of a shader. This speeds up background rendering on particular on older GPUs. See the commit messages of bb2cd7225eb2eeaf2ab343af916eaeef1ceebb78 ce042f7ba1af3f7c3ff125311c4eb82ea2e6b13c 0edd7547c1e095ede1e1f8c45dc93291b4913c33 for a further discussion of performance impacts.
2023-09-22 08:34:56 +00:00
'gpu/gskgpuclearop.c',
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
'gpu/gskgpuclip.c',
gpu: Add colorize shader ... and use it for glyphs. The name is a slight variation of the "coloring" name from the GL renderer. The functionality is exactly what the "glyph" shader from the Vulkan renderer does.
2023-09-16 17:29:30 +00:00
'gpu/gskgpucolorizeop.c',
gpu: Add a color matrix shader This allows avoiding the uber shader in 2 important cases: 1. opacity - and Adwaita uses that a lot 2. color-matrix - it's used for symbolic icons
2023-11-18 03:46:58 +00:00
'gpu/gskgpucolormatrixop.c',
gpu: Add a color shader We don't want to use the pattern shader for simple colors, slow GPUs do not like this at all.
2023-09-21 15:52:06 +00:00
'gpu/gskgpucolorop.c',
gpu: Add a conic gradient shader
2023-12-27 00:20:47 +00:00
'gpu/gskgpuconicgradientop.c',
gpu: Add a color convert shader This shader converts between two color states, by using the same functions that we use on the cpu. The conversion to perform is passed as part of the variation. As premultiplication is part of color states on the shader, we also encode the premultiplication in the shader. And because opacity is a useful optimization, we also allow setting opacity. For now, the only possible color states are srgb and srgb-linear.
2024-06-22 21:53:01 +00:00
'gpu/gskgpuconvertop.c',
gsk: Add a cicp convert shader This shader receives cicp parameters via uniforms, and converts the texture data from or to the output colorstate. It computes the matrix in the vertex shader, and then picks the eotf/oetf according to the cicp parameters in the fragment shader.
2024-07-17 03:51:57 +00:00
'gpu/gskgpuconvertcicpop.c',
gpu: Add a cross-fade shader
2023-12-30 05:41:11 +00:00
'gpu/gskgpucrossfadeop.c',
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
'gpu/gskgpudownloadop.c',
'gpu/gskgpudevice.c',
'gpu/gskgpuframe.c',
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
'gpu/gskgpuglobalsop.c',
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
'gpu/gskgpuimage.c',
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
'gpu/gskgpulineargradientop.c',
gpu: Add a mask shader This shader can take over from the ubershader. And it can be used instead of launching the ubershader when no offscreens are necessary. Also includes an optimization that uses the colorize shader when appropriate.
2023-12-23 22:43:06 +00:00
'gpu/gskgpumaskop.c',
gpu: Add support for texture-scale nodes This adds GSK_GPU_IMAGE_CAN_MIPMAP and GSK_GPU_IMAGE_MIPMAP flags and support to ensure_image() and image creation functions for creating a mipmapped image. Mipmaps are created using the new mipmap op that uses glGenerateMipmap() on GL and equivalent blit ops on Vulkan. This is then used to ensure the image is mipmapped when rendering it with a texture-scale node.
2023-11-01 05:43:15 +00:00
'gpu/gskgpumipmapop.c',
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
'gpu/gskgpunodeprocessor.c',
'gpu/gskgpuop.c',
'gpu/gskgpuprint.c',
gpu: Add a radial gradient shader This is mainly copy/paste, so now this almost identical gradient code exists 3 times. That's kinda suboptimal.
2023-12-27 03:01:11 +00:00
'gpu/gskgpuradialgradientop.c',
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
'gpu/gskgpurenderer.c',
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
'gpu/gskgpurenderpassop.c',
gpu: Add a rounded color shader There's multiple uses I want it for: 1. Generating the box-shadow area for blurring 2. Generating masks for rounded-rect masking 3. Optimizing the common use case of rounded-clip + color Only the last one is implemented in this commit.
2023-10-06 22:27:59 +00:00
'gpu/gskgpuroundedcolorop.c',
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
'gpu/gskgpushaderop.c',
gpu: Add scissor operation Nothing is using it yet (we don't do clipping) apart from initializing the scissor rect at startup.
2023-08-28 08:42:04 +00:00
'gpu/gskgpuscissorop.c',
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
'gpu/gskgputextureop.c',
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
'gpu/gskgpuuploadop.c',
meson: update build files
2016-11-03 08:47:00 +00:00
])
Confine -mf16c to a single source file We can't use this flag for any code that may get run outside the __builtin_cpu_supports() check, and meson doesn't allow per-file cflags. So we have to split this code off into its own static library.
2021-05-05 22:58:23 +00:00
gsk_f16c_sources = files([
Rename ngl to gl We have only one gl renderer now, and it is a bit odd for it not be called gl.
2021-10-07 03:15:25 +00:00
'gl/fp16i.c',
Confine -mf16c to a single source file We can't use this flag for any code that may get run outside the __builtin_cpu_supports() check, and meson doesn't allow per-file cflags. So we have to split this code off into its own static library.
2021-05-05 22:58:23 +00:00
])
meson: add vulkan bits
2017-03-17 23:43:36 +00:00
gsk_public_headers = files([
gsk: Export Cairo renderer
2019-05-01 21:58:57 +00:00
'gskcairorenderer.h',
meson: update build files
2016-11-03 08:47:00 +00:00
'gskenums.h',
Add GskGLShaderNode and GskGLShader A GskGLShader is an abstraction of a GLSL fragment shader that can produce pixel values given inputs: * N (currently max 4) textures * Current arguments for the shader uniform Uniform types are: float,(u)int,bool,vec234) There is also a builder for the uniform arguments which are passed around as immutable GBytes in the built form. A GskGLShaderNode is a render node that renders a GskGLShader inside a specified rectangular bounds. It renders its child nodes as textures and passes those as texture arguments to the shader. You also pass it a uniform arguments object.
2020-09-18 15:46:57 +00:00
'gskglshader.h',
gsk: Add GskPath This commit adds the basic infrastructure for paths. The public APIs consists of GskPath, GskPathPoint and GskPathBuilder. GskPath is a data structure for paths that consists of contours, which in turn might contain Bézier curves. The Bezier data structure is inspired by Skia, with separate arrays for points and operations. One advantage of this arrangement is that start and end points are shared between adjacent curves. A GskPathPoint represents a point on a path, which can be queried for various properties. GskPathBuilder is an auxiliary builder object for paths.
2023-07-08 14:15:22 +00:00
'gskpath.h',
'gskpathbuilder.h',
Add GskPathMeasure GskPathMeasure is the public API for path lengths.
2023-08-13 15:08:22 +00:00
'gskpathmeasure.h',
gsk: Add GskPath This commit adds the basic infrastructure for paths. The public APIs consists of GskPath, GskPathPoint and GskPathBuilder. GskPath is a data structure for paths that consists of contours, which in turn might contain Bézier curves. The Bezier data structure is inspired by Skia, with separate arrays for points and operations. One advantage of this arrangement is that start and end points are shared between adjacent curves. A GskPathPoint represents a point on a path, which can be queried for various properties. GskPathBuilder is an auxiliary builder object for paths.
2023-07-08 14:15:22 +00:00
'gskpathpoint.h',
meson: update build files
2016-11-03 08:47:00 +00:00
'gskrenderer.h',
'gskrendernode.h',
meson: add vulkan bits
2017-03-17 23:43:36 +00:00
'gskroundedrect.h',
Add GskStroke A GskStroke struct collects the parameters that are needed for stroking a path.
2023-07-08 14:32:52 +00:00
'gskstroke.h',
transform: Move to GSK The renaming of the prefix makes this a large patch.
2019-02-28 08:52:49 +00:00
'gsktransform.h',
meson: update build files
2016-11-03 08:47:00 +00:00
'gsktypes.h',
])
build: Ensure that Vulkan shaders are rebuilt if glslc is found If glslc is found, rebuild the shaders from GLSL to SPIR-V; otherwise, we're just going to use the built files we have committed in the source repository.
2017-04-26 15:02:17 +00:00
install_headers(gsk_public_headers, 'gsk.h', subdir: 'gtk-4.0/gsk')
meson: gsk: install public headers
2017-03-18 13:07:38 +00:00
gsk: Export gsk_gl_renderer_new()
2019-05-02 00:13:16 +00:00
gsk_public_gl_headers = files([
Rename ngl to gl We have only one gl renderer now, and it is a bit odd for it not be called gl.
2021-10-07 03:15:25 +00:00
'gl/gskglrenderer.h',
gsk: Export gsk_gl_renderer_new()
2019-05-02 00:13:16 +00:00
])
install_headers(gsk_public_gl_headers, subdir: 'gtk-4.0/gsk/gl')
gsk_public_headers += gsk_public_gl_headers
gsk: include Vulkan renderer in public header The Vulkan renderer can just be public API, because it doesn't expose any Vulkan-specific APIs. And it can just exist when compiled without Vulkan, because it can fail to realize. Also move get rid of the gsk/vulkan/gskvulkanrenderer.h header. It was experimental and isn't necessary now that the renderer is included via gsk.h.
2024-01-06 18:58:24 +00:00
gsk_public_gpu_headers = files([
'gpu/gskvulkanrenderer.h'
])
install_headers(gsk_public_gpu_headers, subdir: 'gtk-4.0/gsk/gpu')
gsk_public_headers += gsk_public_gpu_headers
gsk: Don't autoinclude backend-specific headers Don't install headers for code that we don't build. And don't include those headers in gsk.h. Just as we do in gdk, require applications to include the backend-specific headers they need explicitly. Update the one affected demo, gtk4-node-editor.
2020-04-25 01:38:52 +00:00
if get_variable('broadway_enabled')
gsk_public_broadway_headers = files([
'broadway/gskbroadwayrenderer.h'
])
install_headers(gsk_public_broadway_headers, subdir: 'gtk-4.0/gsk/broadway')
gsk_public_headers += gsk_public_broadway_headers
endif
gsk: Export gsk_broadway_renderer_new() ... when broadway is enabled.
2019-05-02 00:46:23 +00:00
meson: gsk: generate gsk.resources.xml
2017-03-18 12:14:12 +00:00
gsk_private_vulkan_shaders = []
gsk_private_vulkan_compiled_shaders = []
build: Improve vulkan resource handling This fixes the proper dependencies getting set up for generating the shaders and only the necessary things getting rebuilt on resources changing in gsk.
2017-09-05 16:47:10 +00:00
gsk_private_vulkan_compiled_shaders_deps = []
vulkan: Generate vertex array headers from shaders The script is pretty dumb but it does its job.
2023-06-27 04:45:31 +00:00
gsk_private_vulkan_shader_headers = []
meson: gsk: generate gsk.resources.xml
2017-03-18 12:14:12 +00:00
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
if have_vulkan
gsk_private_sources += files([
'gpu/gskvulkanbuffer.c',
'gpu/gskvulkandevice.c',
'gpu/gskvulkanframe.c',
'gpu/gskvulkanimage.c',
'gpu/gskvulkanmemory.c',
gpu: Completely revamp YCbCr handling There is now a GskGpuYcbcr struct that maintains all the Vulkan machinery related to YCbCrConversions. It's a GskGpuCached, so it will make itself go away when it is no longer used, ie a video stopped playing.
2024-07-21 23:24:52 +00:00
'gpu/gskvulkanycbcr.c',
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
])
endif # have_vulkan
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
subdir('gpu/shaders')
broadway: Add GskBroadwayRenderer This is a custom renderer for broadway windows, although at the moment it doesn't really do anything other than the old cairo fallbacks.
2017-11-17 11:04:02 +00:00
if get_variable('broadway_enabled')
gsk: Export gsk_broadway_renderer_new() ... when broadway is enabled.
2019-05-02 00:46:23 +00:00
gsk_public_sources += files([
broadway: Move gsk files to a subdirectory
2019-03-29 08:09:54 +00:00
'broadway/gskbroadwayrenderer.c',
broadway: Add GskBroadwayRenderer This is a custom renderer for broadway windows, although at the moment it doesn't really do anything other than the old cairo fallbacks.
2017-11-17 11:04:02 +00:00
])
endif
build: Don't use configure_file() when custom_target() works These two files don't need to be built when configuring, they are only needed during build.
2023-08-21 03:14:33 +00:00
gsk_resources_xml = custom_target(output: 'gsk.resources.xml',
build: Use a consistent style for Meson files
2020-12-15 12:31:38 +00:00
input: 'gen-gsk-gresources-xml.py',
command: [
find_program('gen-gsk-gresources-xml.py'),
'@OUTPUT@',
Rename ngl to gl We have only one gl renderer now, and it is a bit odd for it not be called gl.
2021-10-07 03:15:25 +00:00
gsk_private_gl_shaders,
build: Use a consistent style for Meson files
2020-12-15 12:31:38 +00:00
gsk_private_vulkan_compiled_shaders,
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gsk_private_vulkan_shaders,
gsk_private_gpu_gl_shaders,
gpu: Change the meson code for how SPIR-V is built This does the same thing, but in a way that's a bit more flexible. And it prepares the next commit...
2023-11-03 05:48:00 +00:00
gsk_private_gpu_vulkan_shaders,
build: Use a consistent style for Meson files
2020-12-15 12:31:38 +00:00
],
)
meson: add vulkan bits
2017-03-17 23:43:36 +00:00
meson: gsk: use gnome.mkenums() to generate enum types
2017-03-18 12:54:33 +00:00
gsk_enums = gnome.mkenums('gskenumtypes',
build: Use a consistent style for Meson files
2020-12-15 12:31:38 +00:00
sources: gsk_public_headers,
c_template: 'gskenumtypes.c.template',
h_template: 'gskenumtypes.h.template',
install_dir: gtk_includedir / 'gtk-4.0/gsk',
install_header: true,
)
meson: gsk: use gnome.mkenums() to generate enum types
2017-03-18 12:54:33 +00:00
gskenum_h = gsk_enums[1]
meson: update build files
2016-11-03 08:47:00 +00:00
meson: gsk: generate gsk.resources.xml
2017-03-18 12:14:12 +00:00
gskresources = gnome.compile_resources('gskresources',
build: Use a consistent style for Meson files
2020-12-15 12:31:38 +00:00
gsk_resources_xml,
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
dependencies: [
gsk_private_vulkan_compiled_shaders_deps,
gpu: Change the meson code for how SPIR-V is built This does the same thing, but in a way that's a bit more flexible. And it prepares the next commit...
2023-11-03 05:48:00 +00:00
gsk_private_gpu_vulkan_shaders,
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
],
build: Use generated SPIR-V files We weren't looking in the build dir for generated files. Actually make sure that we look in the build dir *first*, otherwise glib-compile-resources will still use the wrong files.
2023-05-02 06:41:43 +00:00
source_dir: [meson.current_build_dir(), meson.current_source_dir()],
build: Use a consistent style for Meson files
2020-12-15 12:31:38 +00:00
c_name: '_gsk',
extra_args: [ '--manual-register', ],
)
meson: update build files
2016-11-03 08:47:00 +00:00
build: Ensure that Vulkan shaders are rebuilt if glslc is found If glslc is found, rebuild the shaders from GLSL to SPIR-V; otherwise, we're just going to use the built files we have committed in the source repository.
2017-04-26 15:02:17 +00:00
gsk_gen_headers = [ gskenum_h, ]
meson: update build files
2016-11-03 08:47:00 +00:00
gsk_deps = [
graphene_dep,
pango_dep,
cairo_dep,
rendernodeparser: Parse cairo script Use cairo-script-interpreter to parse the scripts that generate cairo nodes. This requires libcairoscriptinterpreter.so to work properly, but if it isn't found we disable this (unimportant for normal functioning) code and just emits a parser warning. The testsuite requires it however or it will fail. A new test is included that tests all of this.
2019-05-28 03:51:20 +00:00
cairo_csi_dep,
meson: update build files
2016-11-03 08:47:00 +00:00
libgdk_dep,
]
Confine -mf16c to a single source file We can't use this flag for any code that may get run outside the __builtin_cpu_supports() check, and meson doesn't allow per-file cflags. So we have to split this code off into its own static library.
2021-05-05 22:58:23 +00:00
libgsk_f16c = static_library('gsk_f16c',
sources: gsk_f16c_sources,
dependencies: gsk_deps,
include_directories: [ confinc, ],
c_args: [
'-DGTK_COMPILATION',
'-DG_LOG_DOMAIN="Gsk"',
'-DG_LOG_STRUCTURED=1',
] + common_cflags + f16c_cflags,
)
meson: gsk: use gnome.mkenums() to generate enum types
2017-03-18 12:54:33 +00:00
libgsk = static_library('gsk',
build: Use a consistent style for Meson files
2020-12-15 12:31:38 +00:00
sources: [
gsk_public_sources,
gsk_private_sources,
gsk_enums,
gskresources,
vulkan: Generate vertex array headers from shaders The script is pretty dumb but it does its job.
2023-06-27 04:45:31 +00:00
gsk_private_vulkan_shader_headers,
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gsk_private_gpu_shader_headers,
build: Use a consistent style for Meson files
2020-12-15 12:31:38 +00:00
],
dependencies: gsk_deps,
include_directories: [ confinc, ],
c_args: [
'-DGTK_COMPILATION',
'-DG_LOG_DOMAIN="Gsk"',
'-DG_LOG_STRUCTURED=1',
] + common_cflags,
Confine -mf16c to a single source file We can't use this flag for any code that may get run outside the __builtin_cpu_supports() check, and meson doesn't allow per-file cflags. So we have to split this code off into its own static library.
2021-05-05 22:58:23 +00:00
link_with: [ libgdk, libgsk_f16c]
build: Use a consistent style for Meson files
2020-12-15 12:31:38 +00:00
)
meson: update build files
2016-11-03 08:47:00 +00:00
meson: make sure gsk/gdk generated headers exist for libgtk_dep users Add back dependencies on libgdk_dep and libsk_dep which are declared dependencies. We removed this before because these declarations had link_with: lines that dragged in the static libgdk.a and libgsk.a libs which are linked into libgtk-4.so anyway and thus shouldn't be used when linking internal exes/tools against libgtk-4. Remove the static libs from the declared dependencies and have libgtk link those in explicitly, so that the declared deps now just provide all the built dependencies and include dirs and such for declared libgtk_dep users such as the internal exes/tools, which want all the generated gsk/gdk/gtk headers to exist before attempting to compile anything against the gtk+ headers.
2017-03-22 00:45:39 +00:00
# We don't have link_with: to internal static libs here on purpose, just
# list the dependencies and generated headers and such, for use in the
# "public" libgtk_dep used by internal executables.
build: Remove more wrong kwargs declare_dependency does not take a depends: kwarg and meson 0.42.0 started warning about that.
2017-08-15 12:55:17 +00:00
libgsk_dep = declare_dependency(include_directories: [ confinc, ],
build: Use a consistent style for Meson files
2020-12-15 12:31:38 +00:00
sources: [ gskenum_h, ],
meson: Find libcairo-script-interpreter when cairo is a subproject If cairo is a subproject, it's not necessarily installed when gtk is built. In the build tree, libcairo-script-interpreter is not stored in the same directory as other cairo libraries.
2021-03-16 08:52:13 +00:00
dependencies: [libgdk_dep, cairo_csi_dep],
build: Use a consistent style for Meson files
2020-12-15 12:31:38 +00:00
)
Reference in New Issue Copy Permalink