Skip to content
Snippets Groups Projects
Commit fdf0ee0a authored by Jeremy Whiting's avatar Jeremy Whiting
Browse files

Add SrtGraphics wrapper to wrap graphics checker.

SrtGraphics is gobject shaped and gives a public interface
to check graphics capabilities for different window systems and
renderers.
Use wflinfo binaries for checking gl and gles.
If llvmpipe renderer is used, set SOFTWARE_RENDERING issue flag.
parent 2d0ffbc3
No related branches found
No related tags found
1 merge request!24Add SrtGraphics wrapper to wrap graphics checker.
/*< internal_header >*/
/*
* Copyright © 2019 Collabora Ltd.
*
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#pragma once
#include "steam-runtime-tools/graphics.h"
/*
* _srt_graphics_new:
* @multiarch_tuple: A multiarch tuple like %SRT_ABI_I386,
* representing an ABI
* @window_system: The window system to check,
* @rendering_interface: The renderint interface to check,
* @issues: Problems found when checking @multiarch_tuple with
* the given @winsys and @renderer.
*
* Inline convenience function to create a new SrtGraphics.
* This is not part of the public API.
*
* Returns: (transfer full): A new #SrtGraphics
*/
static inline SrtGraphics *_srt_graphics_new (const char *multiarch_tuple,
SrtWindowSystem window_system,
SrtRenderingInterface rendering_interface,
const gchar *renderer_string,
const gchar *version_string,
SrtGraphicsIssues issues);
#ifndef __GTK_DOC_IGNORE__
static inline SrtGraphics *
_srt_graphics_new (const char *multiarch_tuple,
SrtWindowSystem window_system,
SrtRenderingInterface rendering_interface,
const gchar *renderer_string,
const gchar *version_string,
SrtGraphicsIssues issues)
{
g_return_val_if_fail (multiarch_tuple != NULL, NULL);
return g_object_new (SRT_TYPE_GRAPHICS,
"multiarch-tuple", multiarch_tuple,
"issues", issues,
"window-system", window_system,
"rendering-interface", rendering_interface,
"renderer-string", renderer_string,
"version-string", version_string,
NULL);
}
#endif
/*
* Copyright © 2019 Collabora Ltd.
*
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "steam-runtime-tools/graphics.h"
#include "steam-runtime-tools/architecture.h"
#include "steam-runtime-tools/enums.h"
#include "steam-runtime-tools/graphics-internal.h"
#include "steam-runtime-tools/utils-internal.h"
#include <json-glib/json-glib.h>
/**
* SECTION:graphics
* @title: Graphics compatibility check
* @short_description: Get information about system's graphics capabilities
* @include: steam-runtime-tools/steam-runtime-tools.h
*
* #SrtGraphics is an opaque object representing a graphics capabilities.
* This is a reference-counted object: use g_object_ref() and
* g_object_unref() to manage its lifecycle.
*/
struct _SrtGraphics
{
/*< private >*/
GObject parent;
GQuark multiarch_tuple;
SrtWindowSystem window_system;
SrtRenderingInterface rendering_interface;
SrtGraphicsIssues issues;
gchar *renderer_string;
gchar *version_string;
};
struct _SrtGraphicsClass
{
/*< private >*/
GObjectClass parent_class;
};
enum {
PROP_0,
PROP_ISSUES,
PROP_MULTIARCH_TUPLE,
PROP_WINDOW_SYSTEM,
PROP_RENDERING_INTERFACE,
PROP_RENDERER_STRING,
PROP_VERSION_STRING,
N_PROPERTIES
};
G_DEFINE_TYPE (SrtGraphics, srt_graphics, G_TYPE_OBJECT)
static void
srt_graphics_init (SrtGraphics *self)
{
}
static void
srt_graphics_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
SrtGraphics *self = SRT_GRAPHICS (object);
switch (prop_id)
{
case PROP_ISSUES:
g_value_set_flags (value, self->issues);
break;
case PROP_MULTIARCH_TUPLE:
g_value_set_string (value, g_quark_to_string (self->multiarch_tuple));
break;
case PROP_WINDOW_SYSTEM:
g_value_set_enum (value, self->window_system);
break;
case PROP_RENDERING_INTERFACE:
g_value_set_enum (value, self->rendering_interface);
break;
case PROP_RENDERER_STRING:
g_value_set_string (value, self->renderer_string);
break;
case PROP_VERSION_STRING:
g_value_set_string (value, self->version_string);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
srt_graphics_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
SrtGraphics *self = SRT_GRAPHICS (object);
switch (prop_id)
{
case PROP_ISSUES:
/* Construct-only */
g_return_if_fail (self->issues == 0);
self->issues = g_value_get_flags (value);
break;
case PROP_MULTIARCH_TUPLE:
/* Construct-only */
g_return_if_fail (self->multiarch_tuple == 0);
/* Intern the string since we only expect to deal with a few values */
self->multiarch_tuple = g_quark_from_string (g_value_get_string (value));
break;
case PROP_WINDOW_SYSTEM:
/* Construct-only */
g_return_if_fail (self->window_system == 0);
self->window_system = g_value_get_enum (value);
break;
case PROP_RENDERING_INTERFACE:
/* Construct-only */
g_return_if_fail (self->rendering_interface == 0);
self->rendering_interface = g_value_get_enum (value);
break;
case PROP_RENDERER_STRING:
/* Construct only */
g_return_if_fail (self->renderer_string == NULL);
self->renderer_string = g_value_dup_string (value);
break;
case PROP_VERSION_STRING:
/* Construct only */
g_return_if_fail (self->version_string == NULL);
self->version_string = g_value_dup_string (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
srt_graphics_finalize (GObject *object)
{
SrtGraphics *self = SRT_GRAPHICS (object);
g_free (self->renderer_string);
g_free (self->version_string);
G_OBJECT_CLASS (srt_graphics_parent_class)->finalize (object);
}
static GParamSpec *properties[N_PROPERTIES] = { NULL };
static void
srt_graphics_class_init (SrtGraphicsClass *cls)
{
GObjectClass *object_class = G_OBJECT_CLASS (cls);
object_class->get_property = srt_graphics_get_property;
object_class->set_property = srt_graphics_set_property;
object_class->finalize = srt_graphics_finalize;
properties[PROP_ISSUES] =
g_param_spec_flags ("issues", "Issues", "Problems with the graphics stack",
SRT_TYPE_GRAPHICS_ISSUES, SRT_GRAPHICS_ISSUES_NONE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
properties[PROP_MULTIARCH_TUPLE] =
g_param_spec_string ("multiarch-tuple", "Multiarch tuple",
"Which multiarch tuple we are checking, for example "
"x86_64-linux-gnu",
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
properties[PROP_WINDOW_SYSTEM] =
g_param_spec_enum ("window-system", "Window System", "Which window system we are checking.",
SRT_TYPE_WINDOW_SYSTEM, SRT_WINDOW_SYSTEM_GLX,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
properties[PROP_RENDERING_INTERFACE] =
g_param_spec_enum ("rendering-interface", "Rendering Interface", "Which rendering interface we are checking.",
SRT_TYPE_RENDERING_INTERFACE, SRT_RENDERING_INTERFACE_GL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
properties[PROP_RENDERER_STRING] =
g_param_spec_string ("renderer-string", "Found Renderer", "Which renderer was found by checking.",
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
properties[PROP_VERSION_STRING] =
g_param_spec_string ("version-string", "Found version", "Which version of graphics renderer was found from check.",
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
g_object_class_install_properties (object_class, N_PROPERTIES, properties);
}
G_GNUC_INTERNAL SrtGraphicsIssues
srt_check_graphics (const char *multiarch_tuple,
SrtWindowSystem window_system,
SrtRenderingInterface rendering_interface,
SrtGraphics **details_out)
{
GPtrArray *argv = NULL;
gchar *output = NULL;
int exit_status = -1;
JsonParser *parser = NULL;
JsonNode *node = NULL;
JsonObject *object = NULL;
JsonNode *sub_node = NULL;
JsonObject *sub_object = NULL;
const gchar *version_string = NULL;
const gchar *renderer_string = NULL;
GError *error = NULL;
SrtGraphicsIssues issues = SRT_GRAPHICS_ISSUES_NONE;
g_return_val_if_fail (details_out == NULL || *details_out == NULL, SRT_GRAPHICS_ISSUES_INTERNAL_ERROR);
gchar *platformstring = NULL;
argv = g_ptr_array_new_with_free_func (g_free);
if (window_system == SRT_WINDOW_SYSTEM_GLX)
{
platformstring = g_strdup ("glx");
}
else if (window_system == SRT_WINDOW_SYSTEM_X11)
{
if (rendering_interface == SRT_RENDERING_INTERFACE_GL)
{
platformstring = g_strdup ("glx");
window_system = SRT_WINDOW_SYSTEM_GLX;
}
else
{
platformstring = g_strdup ("x11_egl");
window_system = SRT_WINDOW_SYSTEM_EGL_X11;
}
}
else if (window_system == SRT_WINDOW_SYSTEM_EGL_X11)
{
platformstring = g_strdup ("x11_egl");
}
else
{
g_return_val_if_reached (SRT_GRAPHICS_ISSUES_INTERNAL_ERROR);
}
if (rendering_interface == SRT_RENDERING_INTERFACE_GL)
{
g_ptr_array_add (argv, g_strdup_printf ("%s/%s-wflinfo", _srt_get_helpers_path (), multiarch_tuple));
g_ptr_array_add (argv, g_strdup_printf ("--platform=%s", platformstring));
g_ptr_array_add (argv, g_strdup ("--api=gl"));
g_ptr_array_add (argv, g_strdup ("--format=json"));
}
else if (rendering_interface == SRT_RENDERING_INTERFACE_GLESV2)
{
g_ptr_array_add (argv, g_strdup_printf ("%s/%s-wflinfo", _srt_get_helpers_path (), multiarch_tuple));
g_ptr_array_add (argv, g_strdup_printf ("--platform=%s", platformstring));
g_ptr_array_add (argv, g_strdup ("--api=gles2"));
g_ptr_array_add (argv, g_strdup ("--format=json"));
}
else
{
g_return_val_if_reached (SRT_GRAPHICS_ISSUES_INTERNAL_ERROR);
}
g_ptr_array_add (argv, NULL);
if (!g_spawn_sync (NULL, /* working directory */
(gchar **) argv->pdata,
NULL, /* envp */
0, /* flags */
NULL, /* child setup */
NULL, /* user data */
&output, /* stdout */
NULL, /* stderr */
&exit_status,
&error))
{
g_debug ("An error occurred calling the helper: %s", error->message);
issues |= SRT_GRAPHICS_ISSUES_CANNOT_LOAD;
goto out;
}
if (exit_status != 0)
{
g_debug ("... wait status %d", exit_status);
issues |= SRT_GRAPHICS_ISSUES_CANNOT_LOAD;
goto out;
}
/* We can't use `json_from_string()` directly because we are targeting an
* older json-glib version */
parser = json_parser_new ();
if (!json_parser_load_from_data (parser, output, -1, &error))
{
g_debug ("The helper output is not a valid JSON: %s", error->message);
issues |= SRT_GRAPHICS_ISSUES_CANNOT_LOAD;
goto out;
}
node = json_parser_get_root (parser);
object = json_node_get_object (node);
/* Process json output */
if (!json_object_has_member (object, "OpenGL"))
{
g_debug ("The json output doesn't contain an OpenGL object");
issues |= SRT_GRAPHICS_ISSUES_CANNOT_LOAD;
goto out;
}
sub_node = json_object_get_member (object, "OpenGL");
sub_object = json_node_get_object (sub_node);
if (!json_object_has_member (sub_object, "version string") ||
!json_object_has_member (sub_object, "renderer string"))
{
g_debug ("Json output is missing version or renderer");
issues |= SRT_GRAPHICS_ISSUES_CANNOT_LOAD;
goto out;
}
version_string = json_object_get_string_member (sub_object, "version string");
renderer_string = json_object_get_string_member (sub_object, "renderer string");
/* Check renderer to see if we are using software rendering */
if (strstr (renderer_string, "llvmpipe") != NULL ||
strstr (renderer_string, "software rasterizer") != NULL ||
strstr (renderer_string, "softpipe") != NULL)
{
issues |= SRT_GRAPHICS_ISSUES_SOFTWARE_RENDERING;
}
out:
if (details_out != NULL)
*details_out = _srt_graphics_new (multiarch_tuple,
window_system,
rendering_interface,
renderer_string,
version_string,
issues);
if (parser != NULL)
g_object_unref (parser);
g_ptr_array_unref (argv);
g_free (output);
g_clear_error (&error);
return issues;
}
/**
* srt_graphics_get_issues:
* @self: a SrtGraphics object
*
* Return the problems found when loading @self.
*
* Returns: A bitfield containing problems, or %SRT_GRAPHICS_ISSUES_NONE
* if no problems were found
*/
SrtGraphicsIssues
srt_graphics_get_issues (SrtGraphics *self)
{
g_return_val_if_fail (SRT_IS_GRAPHICS (self), SRT_GRAPHICS_ISSUES_INTERNAL_ERROR);
return self->issues;
}
/**
* srt_graphics_get_multiarch_tuple:
* @self: a graphics object
*
* Return the multiarch tuple representing the ABI of @self.
*
* Returns: A Debian-style multiarch tuple, usually %SRT_ABI_I386
* or %SRT_ABI_X86_64
*/
const char *
srt_graphics_get_multiarch_tuple (SrtGraphics *self)
{
g_return_val_if_fail (SRT_IS_GRAPHICS (self), NULL);
return g_quark_to_string (self->multiarch_tuple);
}
/**
* srt_graphics_get_window_system:
* @self: a graphics object
*
* Return the window system tested on the given graphics object.
*
* Returns: An enumeration of #SrtWindowSystem which window system was tested.
*/
SrtWindowSystem
srt_graphics_get_window_system (SrtGraphics *self)
{
// Not sure what to return if self is not a SrtGraphics object, maybe need
// to add a SRT_WINDOW_SYSTEM_NONE ?
g_return_val_if_fail (SRT_IS_GRAPHICS (self), 0);
return self->window_system;
}
/**
* srt_graphics_get_rendering_interface:
* @self: a graphics object
*
* Return the rendering interface which was tested on the given graphics object.
*
* Returns: An enumeration of #SrtRenderingInterface indicating which rendering
* interface was tested.
*/
SrtRenderingInterface
srt_graphics_get_rendering_interface (SrtGraphics *self)
{
g_return_val_if_fail (SRT_IS_GRAPHICS (self), 0);
return self->rendering_interface;
}
/**
* srt_graphics_get_version_string:
* @self: a graphics object
*
* Return the version string found when testing the given graphics.
*
* Returns: A string indicating the version found when testing graphics.
*/
const char *
srt_graphics_get_version_string (SrtGraphics *self)
{
g_return_val_if_fail (SRT_IS_GRAPHICS (self), NULL);
return self->version_string;
}
/**
* srt_graphics_get_renderer_string:
* @self: a graphics object
*
* Return the renderer string found when testing the given graphics.
*
* Returns: A string indicating the renderer found when testing graphics.
*/
const char *
srt_graphics_get_renderer_string (SrtGraphics *self)
{
g_return_val_if_fail (SRT_IS_GRAPHICS (self), NULL);
return self->renderer_string;
}
/*
* Copyright © 2019 Collabora Ltd.
*
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#pragma once
#if !defined(_SRT_IN_SINGLE_HEADER) && !defined(_SRT_COMPILATION)
#error "Do not include directly, use <steam-runtime-tools/steam-runtime-tools.h>"
#endif
#include <glib.h>
#include <glib-object.h>
typedef struct _SrtGraphics SrtGraphics;
typedef struct _SrtGraphicsClass SrtGraphicsClass;
#define SRT_TYPE_GRAPHICS srt_graphics_get_type ()
#define SRT_GRAPHICS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SRT_TYPE_GRAPHICS, SrtGraphics))
#define SRT_GRAPHICS_CLASS(cls) (G_TYPE_CHECK_CLASS_CAST ((cls), SRT_TYPE_GRAPHICS, SrtGraphicsClass))
#define SRT_IS_GRAPHICS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SRT_TYPE_GRAPHICS))
#define SRT_IS_GRAPHICS_CLASS(cls) (G_TYPE_CHECK_CLASS_TYPE ((cls), SRT_TYPE_GRAPHICS))
#define SRT_GRAPHICS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), SRT_TYPE_GRAPHICS, SrtGraphicsClass)
GType srt_graphics_get_type (void);
/**
* SrtGraphicsIssues:
* @SRT_GRAPHICS_ISSUES_NONE: There are no problems
* @SRT_GRAPHICS_ISSUES_INTERNAL_ERROR: An internal error of some kind has occurred
* @SRT_GRAPHICS_ISSUES_CANNOT_LOAD: Unable to load the necessary libraries and create rendering context
* @SRT_GRAPHICS_ISSUES_SOFTWARE_RENDERING: The graphics renderer is software based
*
* A bitfield with flags representing problems with the graphics stack, or
* %SRT_GRAPHICS_ISSUES_NONE (which is numerically zero) if no problems
* were detected.
*
* In general, more bits set means more problems.
*/
typedef enum
{
SRT_GRAPHICS_ISSUES_NONE = 0,
SRT_GRAPHICS_ISSUES_INTERNAL_ERROR = (1 << 0),
SRT_GRAPHICS_ISSUES_CANNOT_LOAD = (1 << 1),
SRT_GRAPHICS_ISSUES_SOFTWARE_RENDERING = (1 << 2),
} SrtGraphicsIssues;
/**
* SrtWindowSystem:
* @SRT_WINDOW_SYSTEM_X11: X11 window system, with GL: equivalent to GLX; with GLES: equivalent to EGL_X11; with Vulkan: use X11
* @SRT_WINDOW_SYSTEM_GLX: GLX window system, only possible with GL
* @SRT_WINDOW_SYSTEM_EGL_X11: EGL_X11 window system, only possible with GL/GLES
*/
typedef enum
{
SRT_WINDOW_SYSTEM_X11,
SRT_WINDOW_SYSTEM_GLX,
SRT_WINDOW_SYSTEM_EGL_X11,
} SrtWindowSystem;
#define SRT_N_WINDOW_SYSTEMS (SRT_WINDOW_SYSTEM_EGL_X11 + 1)
/**
* SrtRenderingInterface:
* @SRT_RENDERING_INTERFACE_GL: GL rendering interface
* @SRT_RENDERING_INTERFACE_GLESV2: GLESv2 rendering interfaces
*/
typedef enum
{
SRT_RENDERING_INTERFACE_GL,
SRT_RENDERING_INTERFACE_GLESV2,
/* ... possible future additions: GLESV1, GLESV3? */
} SrtRenderingInterface;
#define SRT_N_RENDERING_INTERFACES (SRT_RENDERING_INTERFACE_GLESV2 + 1)
G_STATIC_ASSERT (SRT_N_RENDERING_INTERFACES < 100);
SrtGraphicsIssues srt_check_graphics (const char *multiarch_tuple, SrtWindowSystem window_system, SrtRenderingInterface rendering_interface, SrtGraphics **details_out);
const char *srt_graphics_get_multiarch_tuple (SrtGraphics *self);
SrtGraphicsIssues srt_graphics_get_issues (SrtGraphics *self);
SrtWindowSystem srt_graphics_get_window_system (SrtGraphics *self);
SrtRenderingInterface srt_graphics_get_rendering_interface (SrtGraphics *self);
const char *srt_graphics_get_version_string (SrtGraphics *self);
const char *srt_graphics_get_renderer_string (SrtGraphics *self);
......@@ -24,6 +24,8 @@
libsteamrt_sources = [
'architecture-internal.h',
'architecture.c',
'graphics-internal.h',
'graphics.c',
'library-internal.h',
'library.c',
'runtime-internal.h',
......@@ -37,6 +39,7 @@ libsteamrt_sources = [
libsteamrt_public_headers = [
'architecture.h',
'graphics.h',
'library.h',
'runtime.h',
'steam-runtime-tools.h',
......
......@@ -29,6 +29,7 @@
#include <steam-runtime-tools/architecture.h>
#include <steam-runtime-tools/enums.h>
#include <steam-runtime-tools/graphics.h>
#include <steam-runtime-tools/library.h>
#include <steam-runtime-tools/runtime.h>
#include <steam-runtime-tools/steam.h>
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment