265 lines
7.0 KiB
C
265 lines
7.0 KiB
C
#include <cogl/cogl.h>
|
|
#include <glib.h>
|
|
#include <stdio.h>
|
|
|
|
struct {
|
|
CoglFeatureID feature;
|
|
const char *short_description;
|
|
const char *long_description;
|
|
} features[] =
|
|
{
|
|
{
|
|
COGL_FEATURE_ID_TEXTURE_NPOT_BASIC,
|
|
"Non power of two textures (basic)",
|
|
"The hardware supports non power of two textures, but you also "
|
|
"need to check the COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP and "
|
|
"COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT features to know if the "
|
|
"hardware supports npot texture mipmaps or repeat modes other "
|
|
"than COGL_RENDERER_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE respectively."
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP,
|
|
"Non power of two textures (+ mipmap)",
|
|
"Mipmapping is supported in conjuntion with non power of two "
|
|
"textures."
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT,
|
|
"Non power of two textures (+ repeat modes)",
|
|
"Repeat modes other than "
|
|
"COGL_RENDERER_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE are supported by "
|
|
"the hardware in conjunction with non power of two textures."
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_TEXTURE_NPOT,
|
|
"Non power of two textures (fully featured)",
|
|
"Non power of two textures are supported by the hardware. This "
|
|
"is a equivalent to the COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, "
|
|
"COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP and "
|
|
"COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT features combined."
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_TEXTURE_RECTANGLE,
|
|
"Unnormalized coordinate, rectangle textures",
|
|
"Support for rectangular textures with non-normalized texture "
|
|
"coordinates."
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_TEXTURE_3D,
|
|
"3D texture support",
|
|
"3D texture support"
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_OFFSCREEN,
|
|
"Offscreen rendering support",
|
|
"Offscreen rendering support"
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_OFFSCREEN_MULTISAMPLE,
|
|
"Offscreen rendering with multisampling support",
|
|
"Offscreen rendering with multisampling support"
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_ONSCREEN_MULTIPLE,
|
|
"Multiple onscreen framebuffers supported",
|
|
"Multiple onscreen framebuffers supported"
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_GLSL,
|
|
"GLSL support",
|
|
"GLSL support"
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_ARBFP,
|
|
"ARBFP support",
|
|
"ARBFP support"
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_UNSIGNED_INT_INDICES,
|
|
"Unsigned integer indices",
|
|
"COGL_RENDERER_INDICES_TYPE_UNSIGNED_INT is supported in cogl_indices_new()."
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_DEPTH_RANGE,
|
|
"cogl_pipeline_set_depth_range() support",
|
|
"cogl_pipeline_set_depth_range() support",
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_POINT_SPRITE,
|
|
"Point sprite coordinates",
|
|
"cogl_pipeline_set_layer_point_sprite_coords_enabled() is supported"
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_MAP_BUFFER_FOR_READ,
|
|
"Mapping buffers for reading",
|
|
"Mapping buffers for reading"
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_MAP_BUFFER_FOR_WRITE,
|
|
"Mapping buffers for writing",
|
|
"Mapping buffers for writing"
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_MIRRORED_REPEAT,
|
|
"Mirrored repeat wrap modes",
|
|
"Mirrored repeat wrap modes"
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_GLES2_CONTEXT,
|
|
"GLES2 API integration supported",
|
|
"Support for creating a GLES2 context for using the GLES2 API in a "
|
|
"way that's integrated with Cogl."
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_DEPTH_TEXTURE,
|
|
"Depth Textures",
|
|
"CoglFramebuffers can be configured to render their depth buffer into "
|
|
"a texture"
|
|
},
|
|
{
|
|
COGL_FEATURE_ID_PER_VERTEX_POINT_SIZE,
|
|
"Per-vertex point size",
|
|
"cogl_point_size_in can be used as an attribute to specify a per-vertex "
|
|
"point size"
|
|
}
|
|
};
|
|
|
|
static const char *
|
|
get_winsys_name_for_id (CoglWinsysID winsys_id)
|
|
{
|
|
switch (winsys_id)
|
|
{
|
|
case COGL_WINSYS_ID_ANY:
|
|
g_return_val_if_reached ("ERROR");
|
|
case COGL_WINSYS_ID_STUB:
|
|
return "Stub";
|
|
case COGL_WINSYS_ID_GLX:
|
|
return "GLX";
|
|
case COGL_WINSYS_ID_EGL_XLIB:
|
|
return "EGL + Xlib platform";
|
|
case COGL_WINSYS_ID_EGL_NULL:
|
|
return "EGL + NULL window system platform";
|
|
case COGL_WINSYS_ID_EGL_GDL:
|
|
return "EGL + GDL platform";
|
|
case COGL_WINSYS_ID_EGL_WAYLAND:
|
|
return "EGL + Wayland platform";
|
|
case COGL_WINSYS_ID_EGL_KMS:
|
|
return "EGL + KMS platform";
|
|
case COGL_WINSYS_ID_EGL_ANDROID:
|
|
return "EGL + Android platform";
|
|
case COGL_WINSYS_ID_EGL_MIR:
|
|
return "EGL + Mir platform";
|
|
case COGL_WINSYS_ID_WGL:
|
|
return "EGL + Windows WGL platform";
|
|
case COGL_WINSYS_ID_SDL:
|
|
return "EGL + SDL platform";
|
|
}
|
|
g_return_val_if_reached ("Unknown");
|
|
}
|
|
|
|
static void
|
|
feature_cb (CoglFeatureID feature, void *user_data)
|
|
{
|
|
int i;
|
|
for (i = 0; i < sizeof(features) / sizeof(features[0]); i++)
|
|
{
|
|
if (features[i].feature == feature)
|
|
{
|
|
printf (" » %s\n", features[i].short_description);
|
|
return;
|
|
}
|
|
}
|
|
printf (" » Unknown feature %d\n", feature);
|
|
}
|
|
|
|
typedef struct _OutputState
|
|
{
|
|
int id;
|
|
} OutputState;
|
|
|
|
static void
|
|
output_cb (CoglOutput *output, void *user_data)
|
|
{
|
|
OutputState *state = user_data;
|
|
const char *order;
|
|
float refresh;
|
|
|
|
printf (" Output%d:\n", state->id++);
|
|
printf (" » position = (%d, %d)\n",
|
|
cogl_output_get_x (output),
|
|
cogl_output_get_y (output));
|
|
printf (" » resolution = %d x %d\n",
|
|
cogl_output_get_width (output),
|
|
cogl_output_get_height (output));
|
|
printf (" » physical size = %dmm x %dmm\n",
|
|
cogl_output_get_mm_width (output),
|
|
cogl_output_get_mm_height (output));
|
|
switch (cogl_output_get_subpixel_order (output))
|
|
{
|
|
case COGL_SUBPIXEL_ORDER_NONE:
|
|
order = "non-standard";
|
|
break;
|
|
case COGL_SUBPIXEL_ORDER_HORIZONTAL_RGB:
|
|
order = "horizontal,rgb";
|
|
break;
|
|
case COGL_SUBPIXEL_ORDER_HORIZONTAL_BGR:
|
|
order = "horizontal,bgr";
|
|
break;
|
|
case COGL_SUBPIXEL_ORDER_VERTICAL_RGB:
|
|
order = "vertical,rgb";
|
|
break;
|
|
case COGL_SUBPIXEL_ORDER_VERTICAL_BGR:
|
|
order = "vertical,bgr";
|
|
break;
|
|
default:
|
|
order = "unknown";
|
|
break;
|
|
}
|
|
printf (" » sub pixel order = %s\n", order);
|
|
|
|
refresh = cogl_output_get_refresh_rate (output);
|
|
if (refresh)
|
|
printf (" » refresh = %f Hz\n", refresh);
|
|
else
|
|
printf (" » refresh = unknown\n");
|
|
}
|
|
|
|
int
|
|
main (int argc, char **argv)
|
|
{
|
|
CoglRenderer *renderer;
|
|
CoglDisplay *display;
|
|
CoglContext *ctx;
|
|
CoglError *error = NULL;
|
|
CoglWinsysID winsys_id;
|
|
const char *winsys_name;
|
|
OutputState output_state;
|
|
|
|
#ifdef COGL_HAS_EMSCRIPTEN_SUPPORT
|
|
ctx = cogl_sdl_context_new (SDL_USEREVENT, &error);
|
|
#else
|
|
ctx = cogl_context_new (NULL, &error);
|
|
#endif
|
|
if (!ctx) {
|
|
fprintf (stderr, "Failed to create context: %s\n", error->message);
|
|
return 1;
|
|
}
|
|
|
|
display = cogl_context_get_display (ctx);
|
|
renderer = cogl_display_get_renderer (display);
|
|
winsys_id = cogl_renderer_get_winsys_id (renderer);
|
|
winsys_name = get_winsys_name_for_id (winsys_id);
|
|
g_print ("Renderer: %s\n\n", winsys_name);
|
|
|
|
g_print ("Features:\n");
|
|
cogl_foreach_feature (ctx, feature_cb, NULL);
|
|
|
|
g_print ("Outputs:\n");
|
|
output_state.id = 0;
|
|
cogl_renderer_foreach_output (renderer, output_cb, &output_state);
|
|
if (output_state.id == 0)
|
|
printf (" Unknown\n");
|
|
|
|
return 0;
|
|
}
|