mirror of
https://github.com/brl/mutter.git
synced 2024-11-30 03:50:47 -05:00
142b229c5c
This adds a stop-gap mechanism for Cogl to know when the window system is requested to present the current backbuffer to the frontbuffer by adding a _cogl_swap_buffers_notify function that backends are now expected to call right after issuing the equivalent request to OpenGL vie the platforms OpenGL binding layer. This (blindly) updates all the backends to call this new function. For now Cogl doesn't do anything with the notification but the intention is to use it as part of a planned read-pixel optimization which will need to reset some state at the start of each new frame.
622 lines
18 KiB
C
622 lines
18 KiB
C
/* Clutter.
|
|
* An OpenGL based 'interactive canvas' library.
|
|
* Authored By Matthew Allum <mallum@openedhand.com>
|
|
* Copyright (C) 2006-2007 OpenedHand
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <windows.h>
|
|
|
|
#include "clutter-backend-win32.h"
|
|
#include "clutter-stage-win32.h"
|
|
#include "clutter-win32.h"
|
|
#include "clutter-device-manager-win32.h"
|
|
|
|
#include "clutter-event.h"
|
|
#include "clutter-main.h"
|
|
#include "clutter-device-manager-private.h"
|
|
#include "clutter-debug.h"
|
|
#include "clutter-private.h"
|
|
#include "clutter-stage-private.h"
|
|
#include "clutter-version.h"
|
|
|
|
#include "cogl/cogl.h"
|
|
|
|
G_DEFINE_TYPE (ClutterBackendWin32, clutter_backend_win32,
|
|
CLUTTER_TYPE_BACKEND);
|
|
|
|
typedef int (WINAPI * SwapIntervalProc) (int interval);
|
|
|
|
/* singleton object */
|
|
static ClutterBackendWin32 *backend_singleton = NULL;
|
|
|
|
static gchar *clutter_vblank_name = NULL;
|
|
|
|
static HINSTANCE clutter_hinst = NULL;
|
|
|
|
/* various flags corresponding to pre init setup calls */
|
|
static gboolean _no_event_retrieval = FALSE;
|
|
|
|
gboolean
|
|
clutter_backend_win32_pre_parse (ClutterBackend *backend,
|
|
GError **error)
|
|
{
|
|
const gchar *env_string;
|
|
|
|
if ((env_string = g_getenv ("CLUTTER_VBLANK")))
|
|
clutter_vblank_name = g_strdup (env_string);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
clutter_backend_win32_init_events (ClutterBackend *backend)
|
|
{
|
|
ClutterBackendWin32 *backend_win32 = CLUTTER_BACKEND_WIN32 (backend);
|
|
|
|
CLUTTER_NOTE (EVENT, "initialising the event loop");
|
|
|
|
backend_win32->device_manager =
|
|
g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_WIN32,
|
|
"backend", backend_win32,
|
|
NULL);
|
|
|
|
if (!_no_event_retrieval)
|
|
_clutter_backend_win32_events_init (backend);
|
|
}
|
|
|
|
HCURSOR
|
|
_clutter_backend_win32_get_invisible_cursor (ClutterBackend *backend)
|
|
{
|
|
ClutterBackendWin32 *backend_win32 = CLUTTER_BACKEND_WIN32 (backend);
|
|
|
|
if (backend_win32->invisible_cursor == NULL)
|
|
backend_win32->invisible_cursor =
|
|
LoadCursor (clutter_hinst, MAKEINTRESOURCE (42));
|
|
|
|
return backend_win32->invisible_cursor;
|
|
}
|
|
|
|
static const GOptionEntry entries[] =
|
|
{
|
|
{
|
|
"vblank", 0,
|
|
0,
|
|
G_OPTION_ARG_STRING, &clutter_vblank_name,
|
|
"VBlank method to be used (none, default or wgl)", "METHOD"
|
|
},
|
|
{ NULL }
|
|
};
|
|
|
|
void
|
|
clutter_backend_win32_add_options (ClutterBackend *backend,
|
|
GOptionGroup *group)
|
|
{
|
|
g_option_group_add_entries (group, entries);
|
|
}
|
|
|
|
static void
|
|
clutter_backend_win32_finalize (GObject *gobject)
|
|
{
|
|
backend_singleton = NULL;
|
|
|
|
timeEndPeriod (1);
|
|
|
|
G_OBJECT_CLASS (clutter_backend_win32_parent_class)->finalize (gobject);
|
|
}
|
|
|
|
static void
|
|
clutter_backend_win32_dispose (GObject *gobject)
|
|
{
|
|
ClutterBackendWin32 *backend_win32 = CLUTTER_BACKEND_WIN32 (gobject);
|
|
ClutterStageManager *stage_manager;
|
|
|
|
CLUTTER_NOTE (BACKEND, "Disposing the of stages");
|
|
stage_manager = clutter_stage_manager_get_default ();
|
|
|
|
g_object_unref (stage_manager);
|
|
|
|
CLUTTER_NOTE (BACKEND, "Removing the event source");
|
|
_clutter_backend_win32_events_uninit (CLUTTER_BACKEND (backend_win32));
|
|
|
|
/* Unrealize all shaders, since the GL context is going away */
|
|
_clutter_shader_release_all ();
|
|
|
|
if (backend_win32->gl_context)
|
|
{
|
|
wglMakeCurrent (NULL, NULL);
|
|
wglDeleteContext (backend_win32->gl_context);
|
|
backend_win32->gl_context = NULL;
|
|
}
|
|
|
|
if (backend_win32->dummy_dc)
|
|
{
|
|
ReleaseDC (backend_win32->dummy_hwnd, backend_win32->dummy_dc);
|
|
backend_win32->dummy_dc = NULL;
|
|
}
|
|
|
|
if (backend_win32->dummy_hwnd)
|
|
{
|
|
DestroyWindow (backend_win32->dummy_hwnd);
|
|
backend_win32->dummy_hwnd = NULL;
|
|
}
|
|
|
|
G_OBJECT_CLASS (clutter_backend_win32_parent_class)->dispose (gobject);
|
|
}
|
|
|
|
static GObject *
|
|
clutter_backend_win32_constructor (GType gtype,
|
|
guint n_params,
|
|
GObjectConstructParam *params)
|
|
{
|
|
GObjectClass *parent_class;
|
|
GObject *retval;
|
|
|
|
if (!backend_singleton)
|
|
{
|
|
parent_class = G_OBJECT_CLASS (clutter_backend_win32_parent_class);
|
|
retval = parent_class->constructor (gtype, n_params, params);
|
|
|
|
backend_singleton = CLUTTER_BACKEND_WIN32 (retval);
|
|
|
|
return retval;
|
|
}
|
|
|
|
g_warning ("Attempting to create a new backend object. This should "
|
|
"never happen, so we return the singleton instance.");
|
|
|
|
return g_object_ref (backend_singleton);
|
|
}
|
|
|
|
static gboolean
|
|
check_vblank_env (const char *name)
|
|
{
|
|
return clutter_vblank_name && !g_ascii_strcasecmp (clutter_vblank_name, name);
|
|
}
|
|
|
|
ClutterFeatureFlags
|
|
clutter_backend_win32_get_features (ClutterBackend *backend)
|
|
{
|
|
ClutterFeatureFlags flags;
|
|
const gchar *extensions;
|
|
SwapIntervalProc swap_interval;
|
|
ClutterBackendWin32 *backend_win32;
|
|
|
|
/* this will make sure that the GL context exists and is bound to a
|
|
drawable */
|
|
backend_win32 = CLUTTER_BACKEND_WIN32 (backend);
|
|
g_return_val_if_fail (backend_win32->gl_context != NULL, 0);
|
|
g_return_val_if_fail (wglGetCurrentDC () != NULL, 0);
|
|
|
|
extensions = (const gchar *) glGetString (GL_EXTENSIONS);
|
|
|
|
CLUTTER_NOTE (BACKEND,
|
|
"Checking features\n"
|
|
" GL_VENDOR: %s\n"
|
|
" GL_RENDERER: %s\n"
|
|
" GL_VERSION: %s\n"
|
|
" GL_EXTENSIONS: %s\n",
|
|
glGetString (GL_VENDOR),
|
|
glGetString (GL_RENDERER),
|
|
glGetString (GL_VERSION),
|
|
extensions);
|
|
|
|
flags = CLUTTER_FEATURE_STAGE_USER_RESIZE
|
|
| CLUTTER_FEATURE_STAGE_CURSOR
|
|
| CLUTTER_FEATURE_STAGE_MULTIPLE;
|
|
|
|
/* If the VBlank should be left at the default or it has been
|
|
disabled elsewhere (eg NVIDIA) then don't bother trying to check
|
|
for the swap control extension */
|
|
if (getenv ("__GL_SYNC_TO_VBLANK") || check_vblank_env ("default"))
|
|
CLUTTER_NOTE (BACKEND, "vblank sync: left at default at user request");
|
|
else if (_cogl_check_extension ("WGL_EXT_swap_control", extensions)
|
|
&& (swap_interval = (SwapIntervalProc)
|
|
cogl_get_proc_address ("wglSwapIntervalEXT")))
|
|
{
|
|
/* According to the specification for the WGL_EXT_swap_control
|
|
extension the default swap interval is 1 anyway, so if no
|
|
vblank is requested then we should explicitly set it to
|
|
zero */
|
|
if (check_vblank_env ("none"))
|
|
{
|
|
if (swap_interval (0))
|
|
CLUTTER_NOTE (BACKEND, "vblank sync: successfully disabled");
|
|
else
|
|
CLUTTER_NOTE (BACKEND, "vblank sync: disabling failed");
|
|
}
|
|
else
|
|
{
|
|
if (swap_interval (1))
|
|
{
|
|
flags |= CLUTTER_FEATURE_SYNC_TO_VBLANK;
|
|
CLUTTER_NOTE (BACKEND, "vblank sync: wglSwapIntervalEXT "
|
|
"vblank setup success");
|
|
}
|
|
else
|
|
CLUTTER_NOTE (BACKEND, "vblank sync: wglSwapIntervalEXT "
|
|
"vblank setup failed");
|
|
}
|
|
}
|
|
else
|
|
CLUTTER_NOTE (BACKEND, "no use-able vblank mechanism found");
|
|
|
|
CLUTTER_NOTE (BACKEND, "backend features checked");
|
|
|
|
return flags;
|
|
}
|
|
|
|
static ATOM
|
|
clutter_backend_win32_get_dummy_window_class ()
|
|
{
|
|
static ATOM klass = 0;
|
|
|
|
if (klass == 0)
|
|
{
|
|
WNDCLASSW wndclass;
|
|
memset (&wndclass, 0, sizeof (wndclass));
|
|
wndclass.lpfnWndProc = DefWindowProc;
|
|
wndclass.hInstance = GetModuleHandleW (NULL);
|
|
wndclass.lpszClassName = L"ClutterBackendWin32DummyWindow";
|
|
klass = RegisterClassW (&wndclass);
|
|
}
|
|
|
|
return klass;
|
|
}
|
|
|
|
static gboolean
|
|
clutter_backend_win32_pixel_format_is_better (const PIXELFORMATDESCRIPTOR *pfa,
|
|
const PIXELFORMATDESCRIPTOR *pfb)
|
|
{
|
|
/* Always prefer a format with a stencil buffer */
|
|
if (pfa->cStencilBits == 0)
|
|
{
|
|
if (pfb->cStencilBits > 0)
|
|
return TRUE;
|
|
}
|
|
else if (pfb->cStencilBits == 0)
|
|
return FALSE;
|
|
|
|
/* Prefer a bigger color buffer */
|
|
if (pfb->cColorBits > pfa->cColorBits)
|
|
return TRUE;
|
|
else if (pfb->cColorBits < pfa->cColorBits)
|
|
return FALSE;
|
|
|
|
/* Prefer a bigger depth buffer */
|
|
return pfb->cDepthBits > pfa->cDepthBits;
|
|
}
|
|
|
|
static int
|
|
clutter_backend_win32_choose_pixel_format (HDC dc, PIXELFORMATDESCRIPTOR *pfd)
|
|
{
|
|
int i, num_formats, best_pf = 0;
|
|
PIXELFORMATDESCRIPTOR best_pfd;
|
|
|
|
num_formats = DescribePixelFormat (dc, 0, sizeof (best_pfd), NULL);
|
|
|
|
for (i = 1; i <= num_formats; i++)
|
|
{
|
|
memset (pfd, 0, sizeof (*pfd));
|
|
|
|
if (DescribePixelFormat (dc, i, sizeof (best_pfd), pfd)
|
|
/* Check whether this format is useable by Clutter */
|
|
&& ((pfd->dwFlags & (PFD_SUPPORT_OPENGL
|
|
| PFD_DRAW_TO_WINDOW
|
|
| PFD_DOUBLEBUFFER
|
|
| PFD_GENERIC_FORMAT))
|
|
== (PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW))
|
|
&& pfd->iPixelType == PFD_TYPE_RGBA
|
|
&& pfd->cColorBits >= 16 && pfd->cColorBits <= 32
|
|
&& pfd->cDepthBits >= 16 && pfd->cDepthBits <= 32
|
|
/* Check whether this is a better format than one we've
|
|
already found */
|
|
&& (best_pf == 0
|
|
|| clutter_backend_win32_pixel_format_is_better (&best_pfd, pfd)))
|
|
{
|
|
best_pf = i;
|
|
best_pfd = *pfd;
|
|
}
|
|
}
|
|
|
|
*pfd = best_pfd;
|
|
|
|
return best_pf;
|
|
}
|
|
|
|
static gboolean
|
|
clutter_backend_win32_create_context (ClutterBackend *backend,
|
|
GError **error)
|
|
{
|
|
ClutterBackendWin32 *backend_win32 = CLUTTER_BACKEND_WIN32 (backend);
|
|
|
|
/* COGL assumes that there is always a GL context selected; in order
|
|
* to make sure that a WGL context exists and is made current, we
|
|
* use a small dummy window that never gets shown to which we can
|
|
* always fall back if no stage is available
|
|
*/
|
|
if (backend_win32->dummy_hwnd == NULL)
|
|
{
|
|
ATOM window_class = clutter_backend_win32_get_dummy_window_class ();
|
|
|
|
if (window_class == 0)
|
|
{
|
|
g_critical ("Unable to register window class");
|
|
return FALSE;
|
|
}
|
|
|
|
backend_win32->dummy_hwnd =
|
|
CreateWindowW ((LPWSTR) MAKEINTATOM (window_class),
|
|
L".",
|
|
WS_OVERLAPPEDWINDOW,
|
|
CW_USEDEFAULT,
|
|
CW_USEDEFAULT,
|
|
1, 1,
|
|
NULL, NULL,
|
|
GetModuleHandle (NULL),
|
|
NULL);
|
|
|
|
if (backend_win32->dummy_hwnd == NULL)
|
|
{
|
|
g_critical ("Unable to create dummy window");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (backend_win32->dummy_dc == NULL)
|
|
{
|
|
PIXELFORMATDESCRIPTOR pfd;
|
|
int pf;
|
|
|
|
backend_win32->dummy_dc = GetDC (backend_win32->dummy_hwnd);
|
|
|
|
pf = clutter_backend_win32_choose_pixel_format (backend_win32->dummy_dc,
|
|
&pfd);
|
|
|
|
if (pf == 0 || !SetPixelFormat (backend_win32->dummy_dc, pf, &pfd))
|
|
{
|
|
g_critical ("Unable to find suitable GL pixel format");
|
|
ReleaseDC (backend_win32->dummy_hwnd, backend_win32->dummy_dc);
|
|
backend_win32->dummy_dc = NULL;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (backend_win32->gl_context == NULL)
|
|
{
|
|
backend_win32->gl_context = wglCreateContext (backend_win32->dummy_dc);
|
|
|
|
if (backend_win32->gl_context == NULL)
|
|
{
|
|
g_critical ("Unable to create suitable GL context");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
CLUTTER_NOTE (BACKEND, "Selecting dummy 0x%x for the WGL context",
|
|
(unsigned int) backend_win32->dummy_hwnd);
|
|
|
|
wglMakeCurrent (backend_win32->dummy_dc, backend_win32->gl_context);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
clutter_backend_win32_ensure_context (ClutterBackend *backend,
|
|
ClutterStage *stage)
|
|
{
|
|
ClutterStageWindow *impl;
|
|
|
|
if (stage == NULL ||
|
|
CLUTTER_ACTOR_IN_DESTRUCTION (stage) ||
|
|
((impl = _clutter_stage_get_window (stage)) == NULL))
|
|
{
|
|
CLUTTER_NOTE (MULTISTAGE, "Clearing all context");
|
|
|
|
wglMakeCurrent (NULL, NULL);
|
|
}
|
|
else
|
|
{
|
|
ClutterBackendWin32 *backend_win32;
|
|
ClutterStageWin32 *stage_win32;
|
|
|
|
g_return_if_fail (impl != NULL);
|
|
|
|
CLUTTER_NOTE (MULTISTAGE, "Setting context for stage of type %s [%p]",
|
|
g_type_name (G_OBJECT_TYPE (impl)),
|
|
impl);
|
|
|
|
backend_win32 = CLUTTER_BACKEND_WIN32 (backend);
|
|
stage_win32 = CLUTTER_STAGE_WIN32 (impl);
|
|
|
|
/* no GL context to set */
|
|
if (backend_win32->gl_context == NULL)
|
|
return;
|
|
|
|
/* we might get here inside the final dispose cycle, so we
|
|
* need to handle this gracefully
|
|
*/
|
|
if (stage_win32->client_dc == NULL)
|
|
{
|
|
CLUTTER_NOTE (MULTISTAGE,
|
|
"Received a stale stage, clearing all context");
|
|
|
|
if (backend_win32->dummy_dc != NULL)
|
|
wglMakeCurrent (backend_win32->dummy_dc,
|
|
backend_win32->gl_context);
|
|
else
|
|
wglMakeCurrent (NULL, NULL);
|
|
}
|
|
else
|
|
{
|
|
CLUTTER_NOTE (BACKEND,
|
|
"MakeCurrent window %p (%s), context %p",
|
|
stage_win32->hwnd,
|
|
stage_win32->is_foreign_win ? "foreign" : "native",
|
|
backend_win32->gl_context);
|
|
wglMakeCurrent (stage_win32->client_dc,
|
|
backend_win32->gl_context);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
clutter_backend_win32_redraw (ClutterBackend *backend,
|
|
ClutterStage *stage)
|
|
{
|
|
ClutterStageWin32 *stage_win32;
|
|
ClutterStageWindow *impl;
|
|
|
|
impl = _clutter_stage_get_window (stage);
|
|
if (impl == NULL)
|
|
return;
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE_WIN32 (impl));
|
|
|
|
stage_win32 = CLUTTER_STAGE_WIN32 (impl);
|
|
|
|
/* this will cause the stage implementation to be painted */
|
|
_clutter_stage_do_paint (stage, NULL);
|
|
cogl_flush ();
|
|
|
|
if (stage_win32->client_dc)
|
|
{
|
|
SwapBuffers (stage_win32->client_dc);
|
|
_cogl_swap_buffers_notify ();
|
|
}
|
|
}
|
|
|
|
static ClutterStageWindow *
|
|
clutter_backend_win32_create_stage (ClutterBackend *backend,
|
|
ClutterStage *wrapper,
|
|
GError **error)
|
|
{
|
|
ClutterBackendWin32 *backend_win32 = CLUTTER_BACKEND_WIN32 (backend);
|
|
ClutterStageWin32 *stage_win32;
|
|
ClutterStageWindow *stage;
|
|
|
|
CLUTTER_NOTE (BACKEND, "Creating stage of type '%s'",
|
|
g_type_name (CLUTTER_STAGE_TYPE));
|
|
|
|
stage = g_object_new (CLUTTER_TYPE_STAGE_WIN32, NULL);
|
|
|
|
/* copy backend data into the stage */
|
|
stage_win32 = CLUTTER_STAGE_WIN32 (stage);
|
|
stage_win32->backend = backend_win32;
|
|
stage_win32->wrapper = wrapper;
|
|
|
|
return stage;
|
|
}
|
|
|
|
static ClutterDeviceManager *
|
|
clutter_backend_win32_get_device_manager (ClutterBackend *backend)
|
|
{
|
|
ClutterBackendWin32 *backend_win32 = CLUTTER_BACKEND_WIN32 (backend);
|
|
|
|
if (G_UNLIKELY (backend_win32->device_manager == NULL))
|
|
{
|
|
backend_win32->device_manager =
|
|
g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_WIN32,
|
|
"backend", backend_win32,
|
|
NULL);
|
|
}
|
|
|
|
return backend_win32->device_manager;
|
|
}
|
|
|
|
/**
|
|
* clutter_win32_disable_event_retrieval
|
|
*
|
|
* Disables retrieval of Windows messages in the main loop. Use to
|
|
* create event-less canvas.
|
|
*
|
|
* This function can only be called before calling clutter_init().
|
|
*
|
|
* Since: 0.8
|
|
*/
|
|
void
|
|
clutter_win32_disable_event_retrieval (void)
|
|
{
|
|
if (_clutter_context_is_initialized ())
|
|
{
|
|
g_warning ("clutter_win32_disable_event_retrieval() can only be "
|
|
"called before clutter_init()");
|
|
return;
|
|
}
|
|
|
|
_no_event_retrieval = TRUE;
|
|
}
|
|
|
|
static void
|
|
clutter_backend_win32_class_init (ClutterBackendWin32Class *klass)
|
|
{
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
ClutterBackendClass *backend_class = CLUTTER_BACKEND_CLASS (klass);
|
|
|
|
gobject_class->constructor = clutter_backend_win32_constructor;
|
|
gobject_class->dispose = clutter_backend_win32_dispose;
|
|
gobject_class->finalize = clutter_backend_win32_finalize;
|
|
|
|
backend_class->pre_parse = clutter_backend_win32_pre_parse;
|
|
backend_class->init_events = clutter_backend_win32_init_events;
|
|
backend_class->create_stage = clutter_backend_win32_create_stage;
|
|
backend_class->add_options = clutter_backend_win32_add_options;
|
|
backend_class->get_features = clutter_backend_win32_get_features;
|
|
backend_class->redraw = clutter_backend_win32_redraw;
|
|
backend_class->create_context = clutter_backend_win32_create_context;
|
|
backend_class->ensure_context = clutter_backend_win32_ensure_context;
|
|
backend_class->get_device_manager = clutter_backend_win32_get_device_manager;
|
|
}
|
|
|
|
static void
|
|
clutter_backend_win32_init (ClutterBackendWin32 *backend_win32)
|
|
{
|
|
backend_win32->gl_context = NULL;
|
|
backend_win32->invisible_cursor = NULL;
|
|
|
|
/* FIXME: get from GetSystemMetric?
|
|
clutter_backend_set_double_click_time (backend, 250);
|
|
clutter_backend_set_double_click_distance (backend, 5);
|
|
clutter_backend_set_resolution (backend, 96.0);
|
|
*/
|
|
|
|
/* Set the maximum precision for Windows time functions. Without
|
|
this glib will not be able to sleep accurately enough to give a
|
|
reasonable frame rate */
|
|
timeBeginPeriod (1);
|
|
}
|
|
|
|
GType
|
|
_clutter_backend_impl_get_type (void)
|
|
{
|
|
return clutter_backend_win32_get_type ();
|
|
}
|
|
|
|
BOOL WINAPI
|
|
DllMain (HINSTANCE hinst, DWORD reason, LPVOID reserved)
|
|
{
|
|
if (reason == DLL_PROCESS_ATTACH)
|
|
/* Store the module handle so that we can use it to load resources */
|
|
clutter_hinst = hinst;
|
|
|
|
return TRUE;
|
|
}
|