isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-24 12:02:04 +00:00
Code Issues Packages Projects Releases Wiki Activity
f5b95e8087
mutter/cogl/Makefile.am

696 lines
23 KiB
Makefile
Raw Normal View History

Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-28 01:02:02 +00:00
include $(top_srcdir)/build/autotools/Makefile.am.silent
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
# preamble
Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-28 01:02:02 +00:00
NULL =
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
SUBDIRS =
Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-28 01:02:02 +00:00
build: Make cogl.h not conditional on driver defines The main COGL header cogl.h is currently created at configure time because it conditionally includes the driver-dependent defines. This sometimes leads to a stale cogl.h with old definitions which can break the build until you clean out the whole tree and start from scratch. We can generate a stable cogl-defines.h at build time from the equivalent driver-dependent header and let cogl.h include that file instead.
2009-11-18 17:35:07 +00:00
BUILT_SOURCES =
build: Do not build a noinst library for the tesselator Let's try to keep Cogl's build as non-recursive as possible, in the hope that one day we'll be able to make it fully non-recursive along with the rest of Clutter.
2010-09-12 18:25:47 +00:00
build: Make cogl.h not conditional on driver defines The main COGL header cogl.h is currently created at configure time because it conditionally includes the driver-dependent defines. This sometimes leads to a stale cogl.h with old definitions which can break the build until you clean out the whole tree and start from scratch. We can generate a stable cogl-defines.h at build time from the equivalent driver-dependent header and let cogl.h include that file instead.
2009-11-18 17:35:07 +00:00
EXTRA_DIST =
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
CLEANFILES =
DISTCLEANFILES =
Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-28 01:02:02 +00:00
build: Do not build a noinst library for the tesselator Let's try to keep Cogl's build as non-recursive as possible, in the hope that one day we'll be able to make it fully non-recursive along with the rest of Clutter.
2010-09-12 18:25:47 +00:00
noinst_LTLIBRARIES =
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
lib_LTLIBRARIES =
build: Do not build a noinst library for the tesselator Let's try to keep Cogl's build as non-recursive as possible, in the hope that one day we'll be able to make it fully non-recursive along with the rest of Clutter.
2010-09-12 18:25:47 +00:00
Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-28 01:02:02 +00:00
INCLUDES = \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
-I$(top_srcdir) \
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
-I$(top_builddir) \
build: Add tesselator to the include paths
2010-09-13 10:31:46 +00:00
-I$(srcdir)/tesselator \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
-I$(srcdir)/winsys \
Re-organize the source layout As part of an effort towards being able to write non-opengl based backends for Cogl this moves most of the opengl specific code under drivers/gl. drivers/gl and drivers/gles have been moved to drivers/gl/gl and drivers/gl/es respectively. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 7dc482facb0a265c7f48660079e7e12dd7a2813e)
2012-09-12 20:25:11 +00:00
-I$(srcdir)/driver/gl \
-I$(srcdir)/driver/gl/gl \
-I$(srcdir)/driver/gl/gles \
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
$(NULL)
build: don't include deps/glib headers if glib enabled If we're using the system glib library then we need to make sure not to include headers under deps/glib otherwise we end up with with incompatible typedefs that break the build. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5d5fc97b59951ec56a4193b7ee7909ebd3cfbb94)
2012-09-24 15:42:44 +00:00
if !USE_GLIB
INCLUDES += -I$(top_builddir)/deps/glib
endif
build: Clean up COGL build flags
2010-01-13 15:40:36 +00:00
AM_CPPFLAGS = \
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
-DG_LOG_DOMAIN=\"Cogl\" \
Mass rename CLUTTER_COMPILATION to COGL_COMPILATION Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit a99512e5798e48ffa3a9a1a7eb98bc55647ee1b6)
2012-06-20 17:49:08 +00:00
-DCOGL_COMPILATION \
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 19:44:56 +00:00
-DCOGL_GL_LIBNAME=\"$(COGL_GL_LIBNAME)\" \
-DCOGL_GLES1_LIBNAME=\"$(COGL_GLES1_LIBNAME)\" \
-DCOGL_GLES2_LIBNAME=\"$(COGL_GLES2_LIBNAME)\" \
cogl: Bind the locale dir for the Cogl domain dgettext (which Cogl is using) doesn't work unless you first tell gettext where the locale dir is for the library's domain. This just adds the necessary calls into _cogl_init. https://bugzilla.gnome.org/show_bug.cgi?id=658700 Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-09-10 08:51:42 +00:00
-DCOGL_LOCALEDIR=\""$(localedir)"\" \
build: Clean up COGL build flags
2010-01-13 15:40:36 +00:00
$(NULL)
Make the default driver selectable at configure time When building COGL with multiple backends it can be useful to force a default driver to be selected. For example while for Debian we do want to build the GL renderer on ARM, GLESv2 is much more suitable as the default renderer on that platform. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 8a43aa7167b56784f7b50c557391b990861d594f)
2012-06-20 07:47:41 +00:00
if HAVE_COGL_DEFAULT_DRIVER
AM_CPPFLAGS += \
-DCOGL_DEFAULT_DRIVER=\"$(COGL_DEFAULT_DRIVER)\"
endif
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
AM_CFLAGS = $(COGL_DEP_CFLAGS) $(COGL_EXTRA_CFLAGS) $(MAINTAINER_CFLAGS)
build: Clean up COGL build flags
2010-01-13 15:40:36 +00:00
Avoid including the EGL headers from the public Cogl headers Otherwise, X11 identifiers may leak and cause havoc in big applications Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit ed0cdca0eca815543619fe72fbd42d662d53f92d)
2012-07-10 13:14:07 +00:00
BUILT_SOURCES += cogl-defines.h cogl-egl-defines.h cogl-gl-header.h
DISTCLEANFILES += cogl-defines.h cogl-egl-defines.h cogl-gl-header.h
EXTRA_DIST += cogl-defines.h.in cogl-egl-defines.h.in cogl-gl-header.h.in
cogl: Remove cogl-defines.h.in from the driver make files Commit 7fae8ac051292 changed cogl-defines.h.in so there is only a single copy in clutter/cogl/ instead of one for each driver. However the old files were still mentioned in the EXTRA_DIST of the Makefile.am so make distcheck was failing.
2010-06-23 16:29:08 +00:00
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
# Note: The cogl-1.0/cogl-gl-1.0 files are essentially for
# compatability only. I'm not really sure who could possibly be using
# them so we may decide to remove them entirely at some point.
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
pc_files = \
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
cogl-1.0.pc \
cogl-gl-1.0.pc
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
Make it clearer that the 2.0 API is experimental This explicitly renames the cogl-2.0 reference manual to cogl-2.0-experimental and renames the cogl-2.0 pkg-config file to cogl-2.0-experimental.pc. Hopefully this should avoid miss-understandings.
2011-06-10 17:47:12 +00:00
pc_files += cogl-$(COGL_API_VERSION)-experimental.pc
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
cogl-gl-1.0.pc: cogl-1.0.pc
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
$(QUIET_GEN)cp -f $< $(@F)
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = $(pc_files)
Fixes for make distcheck
2011-06-13 11:42:25 +00:00
EXTRA_DIST += cogl-1.0.pc.in cogl-$(COGL_API_VERSION)-experimental.pc.in
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
DISTCLEANFILES += $(pc_files)
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
# public 1.x api headers
cogl_1_public_h = \
Move all types/prototypes from cogl.h -> cogl[1]-context.h So we can get to the point where cogl.h is merely an aggregation of header includes for the 1.x api this moves all the function prototypes and type definitions into a cogl-context.h and a new cogl1-context.h. Ideally no code internally should ever need to include cogl.h as it just represents the public facing header for accessing the 1.x api which should only be used by Clutter. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 21:46:39 +00:00
$(srcdir)/cogl1-context.h \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-bitmap.h \
$(srcdir)/cogl-color.h \
$(srcdir)/cogl-fixed.h \
cogl: rename CoglMaterial -> CoglPipeline This applies an API naming change that's been deliberated over for a while now which is to rename CoglMaterial to CoglPipeline. For now the new pipeline API is marked as experimental and public headers continue to talk about materials not pipelines. The CoglMaterial API is now maintained in terms of the cogl_pipeline API internally. Currently this API is targeting Cogl 2.0 so we will have time to integrate it properly with other upcoming Cogl 2.0 work. The basic reasons for the rename are: - That the term "material" implies to many people that they are constrained to fragment processing; perhaps as some kind of high-level texture abstraction. - In Clutter they get exposed by ClutterTexture actors which may be re-inforcing this misconception. - When comparing how other frameworks use the term material, a material sometimes describes a multi-pass fragment processing technique which isn't the case in Cogl. - In code, "CoglPipeline" will hopefully be a much more self documenting summary of what these objects represent; a full GPU pipeline configuration including, for example, vertex processing, fragment processing and blending. - When considering the API documentation story, at some point we need a document introducing developers to how the "GPU pipeline" works so it should become intuitive that CoglPipeline maps back to that description of the GPU pipeline. - This is consistent in terminology and concept to OpenGL 4's new pipeline object which is a container for program objects. Note: The cogl-material.[ch] files have been renamed to cogl-material-compat.[ch] because otherwise git doesn't seem to treat the change as a moving the old cogl-material.c->cogl-pipeline.c and so we loose all our git-blame history.
2010-10-27 17:54:57 +00:00
$(srcdir)/cogl-material-compat.h \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-matrix.h \
$(srcdir)/cogl-offscreen.h \
cogl: cleanly separate primitives + paths code The function prototypes for the primitives API were spread between cogl-path.h and cogl-texture.h and should have been in a cogl-primitives.h. As well as shuffling the prototypes around into more sensible places this commit splits the cogl-path API out from cogl-primitives.c into a cogl-path.c
2010-02-10 22:30:37 +00:00
$(srcdir)/cogl-primitives.h \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-path.h \
Add -Wmissing-declarations to maintainer flags and fix problems This option to GCC makes it give a warning whenever a global function is defined without a declaration. This should catch cases were we've defined a function but forgot to put it in a header. In that case it is either only used within one file so we should make it static or we should declare it in a header. The following changes where made to fix problems: • Some functions were made static • cogl-path.h (the one containing the 1.0 API) was split into two files, one defining the functions and one defining the enums so that cogl-path.c can include the enum and function declarations from the 2.0 API as well as the function declarations from the 1.0 API. • cogl2-clip-state has been removed. This only had one experimental function called cogl_clip_push_from_path but as this is unstable we might as well remove it favour of the equivalent cogl_framebuffer_* API. • The GLX, SDL and WGL winsys's now have a private header to define their get_vtable function instead of directly declaring in the C file where it is called. • All places that were calling COGL_OBJECT_DEFINE need to have the cogl_is_whatever function declared so these have been added either as a public function or in a private header. • Some files that were not including the header containing their function declarations have been fixed to do so. • Any unused error quark functions have been removed. If we later want them we should add them back one by one and add a declaration for them in a header. • _cogl_is_framebuffer has been renamed to cogl_is_framebuffer and made a public function with a declaration in cogl-framebuffer.h • Similarly for CoglOnscreen. • cogl_vdraw_indexed_attributes is called cogl_framebuffer_vdraw_indexed_attributes in the header. The definition has been changed to match the header. • cogl_index_buffer_allocate has been removed. This had no declaration and I'm not sure what it's supposed to do. • CoglJournal has been changed to use the internal CoglObject macro so that it won't define an exported cogl_is_journal symbol. • The _cogl_blah_pointer_from_handle functions have been removed. CoglHandle isn't used much anymore anyway and in the few places where it is used I think it's safe to just use the implicit cast from void* to the right type. • The test-utils.h header for the conformance tests explicitly disables the -Wmissing-declaration option using a pragma because all of the tests declare their main function without a header. Any mistakes relating to missing declarations aren't really important for the tests. • cogl_quaternion_init_from_quaternion and init_from_matrix have been given declarations in cogl-quaternion.h Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-06 18:21:28 +00:00
$(srcdir)/cogl-path-functions.h \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-shader.h \
$(srcdir)/cogl-texture.h \
$(srcdir)/cogl-types.h \
$(srcdir)/cogl-vertex-buffer.h \
Add temporary cogl-clutter.h to aid splitting out Cogl This gives us a way to clearly track the internal Cogl API that Clutter depends on. The aim is to split Cogl out from Clutter into a standalone 3D graphics API and eventually we want to get rid of any private interfaces for Clutter so its useful to have a handle on that task. Actually it's not as bad as I was expecting though.
2011-02-22 18:25:29 +00:00
$(srcdir)/cogl-clutter.h \
build: Make cogl.h not conditional on driver defines The main COGL header cogl.h is currently created at configure time because it conditionally includes the driver-dependent defines. This sometimes leads to a stale cogl.h with old definitions which can break the build until you clean out the whole tree and start from scratch. We can generate a stable cogl-defines.h at build time from the equivalent driver-dependent header and let cogl.h include that file instead.
2009-11-18 17:35:07 +00:00
$(srcdir)/cogl.h \
Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-28 01:02:02 +00:00
$(NULL)
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
# experimental 2.0 api headers
# Note: we don't run glib-mkenums over these headers
path 2.0: update path API for experimental 2.0 API When COGL_ENABLE_EXPERIMENTAL_2_0_API is defined cogl.h will now include cogl2-path.h which changes cogl_path_new() so it can directly return a CoglPath pointer; it no longer exposes a prototype for cogl_{get,set}_path and all the remaining cogl_path_ functions now take an explicit path as their first argument. The idea is that we want to encourage developers to retain path objects for as long as possible so they can take advantage of us uploading the path geometry to the GPU. Currently although it is possible to start a new path and query the current path, it is not convenient. The other thing is that we want to get Cogl to the point where nothing depends on a global, current context variable. This will allow us to one day define a sensible threading model if/when that is ever desired.
2010-11-04 00:27:47 +00:00
cogl_experimental_h = \
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
$(srcdir)/cogl-object.h \
Adds renderer,display,onscreen-template and swap-chain stubs As part of the process of splitting Cogl out as a standalone graphics API we need to introduce some API concepts that will allow us to initialize a new CoglContext when Clutter isn't there to handle that for us... The new objects roughly in the order that they are (optionally) involved in constructing a context are: CoglRenderer, CoglOnscreenTemplate, CoglSwapChain and CoglDisplay. Conceptually a CoglRenderer represents a means for rendering. Cogl supports rendering via OpenGL or OpenGL ES 1/2.0 and those APIs are accessed through a number of different windowing APIs such as GLX, EGL, SDL or WGL and more. Potentially in the future Cogl could render using D3D or even by using libdrm and directly banging the hardware. All these choices are wrapped up in the configuration of a CoglRenderer. Conceptually a CoglDisplay represents a display pipeline for a renderer. Although Cogl doesn't aim to provide a detailed abstraction of display hardware, on some platforms we can give control over multiple display planes (On TV platforms for instance video content may be on one plane and 3D would be on another so a CoglDisplay lets you select the plane up-front.) Another aspect of CoglDisplay is that it lets us negotiate a display pipeline that best supports the type of CoglOnscreen framebuffers we are planning to create. For instance if you want transparent CoglOnscreen framebuffers then we have to be sure the display pipeline wont discard the alpha component of your framebuffers. Or if you want to use double/tripple buffering that requires support from the display pipeline. CoglOnscreenTemplate and CoglSwapChain are how we describe our default CoglOnscreen framebuffer configuration which can affect the configuration of the display pipeline. The default/simple way we expect most CoglContexts to be constructed will be via something like: if (!cogl_context_new (NULL, &error)) g_error ("Failed to construct a CoglContext: %s", error->message); Where that NULL is for an optional "display" parameter and NULL says to Cogl "please just try to do something sensible". If you want some more control though you can manually construct a CoglDisplay something like: display = cogl_display_new (NULL, NULL); cogl_gdl_display_set_plane (display, plane); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message); And in a similar fashion to cogl_context_new() you can optionally pass a NULL "renderer" and/or a NULL "onscreen template" so Cogl will try to just do something sensible. If you need to change the CoglOnscreen defaults you can provide a template something like: chain = cogl_swap_chain_new (); cogl_swap_chain_set_has_alpha (chain, TRUE); cogl_swap_chain_set_length (chain, 3); onscreen_template = cogl_onscreen_template_new (chain); cogl_onscreen_template_set_pixel_format (onscreen_template, COGL_PIXEL_FORMAT_RGB565); display = cogl_display_new (NULL, onscreen_template); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message);
2011-02-25 17:06:50 +00:00
$(srcdir)/cogl-renderer.h \
$(srcdir)/cogl-swap-chain.h \
$(srcdir)/cogl-onscreen-template.h \
$(srcdir)/cogl-display.h \
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
$(srcdir)/cogl-context.h \
pipeline: split out all core state apis Since cogl-pipeline.c has become very unwieldy this make a start at trying to shape this code back into a manageable state. This patche moves all the API relating to core pipeline state into cogl-pipeline-state.c. This doesn't move code relating to layer state out nor does it move any of the code supporting the core design of CoglPipeline itself. This change alone factors out 2k lines of code from cogl-pipeline.c which is obviously a good start. The next step will be to factor out the layer state and then probably look at breaking all of this state code down into state-groups. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-07 22:44:37 +00:00
$(srcdir)/cogl-pipeline.h \
$(srcdir)/cogl-pipeline-state.h \
pipeline: split out all layer state apis As part of an on-going effort to get cogl-pipeline.c into a more maintainable state this splits out all the apis relating just to layer state. This just leaves code relating to the core CoglPipeline and CoglPipelineLayer design left in cogl-pipeline.c. This splits out around 2k more lines from cogl-pipeline.c although we are still left with nearly 4k lines so we still have some way to go! Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-07 23:42:22 +00:00
$(srcdir)/cogl-pipeline-layer-state.h \
Add a CoglSnippet type This adds a CoglObject called CoglSnippet which will be used to store strings used as GLSL snippets to be attached at hook points to a CoglPipeline. The snippets can currently contain three strings: declarations - This will be placed in the global scope and is intended to be used to declare uniforms, attributes and functions. pre - This will be inserted before the hook point. post - This will be inserted after the hook point. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-17 16:38:49 +00:00
$(srcdir)/cogl-snippet.h \
path 2.0: update path API for experimental 2.0 API When COGL_ENABLE_EXPERIMENTAL_2_0_API is defined cogl.h will now include cogl2-path.h which changes cogl_path_new() so it can directly return a CoglPath pointer; it no longer exposes a prototype for cogl_{get,set}_path and all the remaining cogl_path_ functions now take an explicit path as their first argument. The idea is that we want to encourage developers to retain path objects for as long as possible so they can take advantage of us uploading the path geometry to the GPU. Currently although it is possible to start a new path and query the current path, it is not convenient. The other thing is that we want to get Cogl to the point where nothing depends on a global, current context variable. This will allow us to one day define a sensible threading model if/when that is ever desired.
2010-11-04 00:27:47 +00:00
$(srcdir)/cogl2-path.h \
Adds initial GLES2 integration support This makes it possible to integrate existing GLES2 code with applications using Cogl as the rendering api. Currently all GLES2 usage is handled with separate GLES2 contexts to ensure that GLES2 api usage doesn't interfere with Cogl's own use of OpenGL[ES]. The api has been designed though so we can provide tighter integration later. The api would allow us to support GLES2 virtualized on top of an OpenGL/GLX driver as well as GLES2 virtualized on the core rendering api of Cogl itself. Virtualizing the GLES2 support on Cogl will allow us to take advantage of Cogl debugging facilities as well as let us optimize the cost of allocating multiple GLES2 contexts and switching between them which can both be very expensive with many drivers. As as a side effect of this patch Cogl can also now be used as a portable window system binding API for GLES2 as an alternative to EGL. Parts of this patch are based on work done by Tomeu Vizoso <tomeu.vizoso@collabora.com> who did the first iteration of adding GLES2 API support to Cogl so that WebGL support could be added to webkit-clutter. This patch adds a very minimal cogl-gles2-context example that shows how to create a gles2 context, clear the screen to a random color and also draw a triangle with the cogl api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 4bb6eff3dbd50d8fef7d6bdbed55c5aaa70036a8)
2012-03-06 03:21:30 +00:00
$(srcdir)/cogl-gles2.h \
$(srcdir)/cogl-gles2-types.h \
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
$(srcdir)/cogl-index-buffer.h \
$(srcdir)/cogl-attribute-buffer.h \
$(srcdir)/cogl-indices.h \
$(srcdir)/cogl-attribute.h \
$(srcdir)/cogl-primitive.h \
$(srcdir)/cogl-clip-state.h \
$(srcdir)/cogl-framebuffer.h \
$(srcdir)/cogl-onscreen.h \
$(srcdir)/cogl-vector.h \
$(srcdir)/cogl-euler.h \
$(srcdir)/cogl-quaternion.h \
$(srcdir)/cogl-poll.h \
$(srcdir)/cogl-texture-3d.h \
$(srcdir)/cogl-texture-2d.h \
texture-2d: factor out all GL specific code This factors out all of the OpenGL specific code in cogl-texture-2d.c into cogl-texture-2d-gl.c and where necessary adds indirection through the CoglDriver vtable so that we can eventually start to experiment with non-OpenGL backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit ec57588671696bbe7ce714bdfe7324236146c9c0)
2012-09-10 20:45:33 +00:00
$(srcdir)/cogl-texture-2d-gl.h \
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
$(srcdir)/cogl-texture-rectangle.h \
$(srcdir)/cogl-texture-2d-sliced.h \
$(srcdir)/cogl-sub-texture.h \
$(srcdir)/cogl-meta-texture.h \
Add a CoglPrimitiveTexture interface This interface represents any textures that are backed by a single texture in GL and that can be used directly with the cogl_framebuffer_draw_attributes family of functions. This currently equates to CoglTexture2D, CoglTexture3D and CoglTextureRectangle. The interface currently has only one method called cogl_primitive_set_auto_mipmap. This replaces the COGL_TEXTURE_NO_AUTO_MIPMAP flag from the CoglTextureFlags parameter in the constructors. None of the other flags in CoglTextureFlags make sense for primitive textures so it doesn't seem like a good idea to need them for primitive constructors. There is a boolean in the vtable to mark whether a texture type is primitive which the new cogl_is_primitive function uses. There is also a new texture virtual called set_auto_mipmap which is only required to be implemented for primitive textures. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 14:09:43 +00:00
$(srcdir)/cogl-primitive-texture.h \
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
$(srcdir)/cogl-depth-state.h \
$(srcdir)/cogl-buffer.h \
$(srcdir)/cogl-pixel-buffer.h \
2.0: Add cogl2-experimental.h + don't pollute .pc CFLAGS Instead of adding -DCOGL_ENABLE_EXPERIMENTAL_2_0_API to the cogl-2.0-experimental.pc file we now install a cogl2-experimental.h that #defines COGL_ENABLE_EXPERIMENTAL_2_0_API before including cogl.h. The problem with having the define in the .pc file is that you might develop a library that depends on the experimental 2.0 api internally and then you might want to use that library with Clutter which still uses the 1.0 API but the .pc file for your library will indirectly, automatically enable the 2.0 api which can cause conflicts.
2011-09-05 21:44:37 +00:00
$(srcdir)/cogl2-experimental.h \
Add compatibility API for functions removed after 1.9.8 The cleanup in 185630085 removed some symbols that were previously exported as public experimental API in Cogl 1.9.8. That release is already well after the point where we were meant to freeze the ABI so we probably shouldn't be breaking it again. This patch adds the removed functions back in so that for 1.9.10 we won't have to bump the soname. The symbols are bundled together in a new file called cogl2-compatibility.c so that they will be easy to remove again after we can break ABI. It is expected that we will revert this patch immediately after branching for Cogl 1.10. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-09 16:09:13 +00:00
$(srcdir)/cogl2-compatibility.h \
Add a cogl-version header This adds a version header which contains macros to define which version of Cogl the application is being compiled against. This helps applications that want to support multiple incompatible versions of Cogl at compile time. The macros are called COGL_VERSION_{MAJOR,MINOR,MICRO}. This does not match Clutter which names them CLUTTER_{MAJOR,MINOR,MICRO}_VERSION but I think the former is nicer and it at least matches Cairo and Pango. The values of the macro are defined to COGL_VERSION_*_INTERNAL which is generated by the configure script into cogl-defines.h. There is also a macro for the entire version as a string called COGL_VERSION_STRING. The internal utility macros for encoding a 3 part version number into a single integer have been moved into the new header so they can be used publicly as a convenient way to check if the version is within a particular range. There is also a COGL_VERSION_CHECK macro for the very common case that a feature will be used since a particular version of Cogl. There is a macro called COGL_VERSION which contains the pre-encoded version of Cogl being compiled against for convenience. Unlike in Clutter this patch does not add any runtime version identification mechanism. A test case is also added which just contains static asserts to sanity check the macros. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3480cf140dc355fa87ab3fbcf0aeeb0124798a8f)
2012-04-23 13:09:19 +00:00
$(srcdir)/cogl-version.h \
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
$(srcdir)/cogl-error.h \
path 2.0: update path API for experimental 2.0 API When COGL_ENABLE_EXPERIMENTAL_2_0_API is defined cogl.h will now include cogl2-path.h which changes cogl_path_new() so it can directly return a CoglPath pointer; it no longer exposes a prototype for cogl_{get,set}_path and all the remaining cogl_path_ functions now take an explicit path as their first argument. The idea is that we want to encourage developers to retain path objects for as long as possible so they can take advantage of us uploading the path geometry to the GPU. Currently although it is possible to start a new path and query the current path, it is not convenient. The other thing is that we want to get Cogl to the point where nothing depends on a global, current context variable. This will allow us to one day define a sensible threading model if/when that is ever desired.
2010-11-04 00:27:47 +00:00
$(NULL)
Avoid including the EGL headers from the public Cogl headers Otherwise, X11 identifiers may leak and cause havoc in big applications Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit ed0cdca0eca815543619fe72fbd42d662d53f92d)
2012-07-10 13:14:07 +00:00
cogl_nodist_experimental_h = \
$(NULL)
Adds a NOP driver This adds a new "nop" driver that does nothing. This can be selected at runtime either with the COGL_DRIVER=nop environment variable or by passing COGL_DRIVER_NOP to cogl_renderer_set_driver() Adding the nop driver gives us a way to test workloads without any driver and hardware overheads which can help us understand how Cogl's state tracking performs in isolation. Having a nop driver can also serve as an shell/outline for creating other drivers later. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 90587418233b6438290741d80aedf193ae660cad)
2012-09-12 21:39:46 +00:00
# nop driver
cogl_driver_sources = \
$(srcdir)/driver/nop/cogl-driver-nop.c \
$(srcdir)/driver/nop/cogl-framebuffer-nop-private.h \
$(srcdir)/driver/nop/cogl-framebuffer-nop.c \
$(srcdir)/driver/nop/cogl-attribute-nop-private.h \
$(srcdir)/driver/nop/cogl-attribute-nop.c \
$(srcdir)/driver/nop/cogl-clip-stack-nop-private.h \
$(srcdir)/driver/nop/cogl-clip-stack-nop.c \
$(srcdir)/driver/nop/cogl-texture-2d-nop-private.h \
$(srcdir)/driver/nop/cogl-texture-2d-nop.c \
$(NULL)
Re-organize the source layout As part of an effort towards being able to write non-opengl based backends for Cogl this moves most of the opengl specific code under drivers/gl. drivers/gl and drivers/gles have been moved to drivers/gl/gl and drivers/gl/es respectively. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 7dc482facb0a265c7f48660079e7e12dd7a2813e)
2012-09-12 20:25:11 +00:00
# gl driver sources
Adds initial GLES2 integration support This makes it possible to integrate existing GLES2 code with applications using Cogl as the rendering api. Currently all GLES2 usage is handled with separate GLES2 contexts to ensure that GLES2 api usage doesn't interfere with Cogl's own use of OpenGL[ES]. The api has been designed though so we can provide tighter integration later. The api would allow us to support GLES2 virtualized on top of an OpenGL/GLX driver as well as GLES2 virtualized on the core rendering api of Cogl itself. Virtualizing the GLES2 support on Cogl will allow us to take advantage of Cogl debugging facilities as well as let us optimize the cost of allocating multiple GLES2 contexts and switching between them which can both be very expensive with many drivers. As as a side effect of this patch Cogl can also now be used as a portable window system binding API for GLES2 as an alternative to EGL. Parts of this patch are based on work done by Tomeu Vizoso <tomeu.vizoso@collabora.com> who did the first iteration of adding GLES2 API support to Cogl so that WebGL support could be added to webkit-clutter. This patch adds a very minimal cogl-gles2-context example that shows how to create a gles2 context, clear the screen to a random color and also draw a triangle with the cogl api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 4bb6eff3dbd50d8fef7d6bdbed55c5aaa70036a8)
2012-03-06 03:21:30 +00:00
cogl_gl_prototypes_h = \
$(srcdir)/gl-prototypes/cogl-gles2-functions.h \
$(srcdir)/gl-prototypes/cogl-core-functions.h \
$(srcdir)/gl-prototypes/cogl-in-gles-core-functions.h \
$(srcdir)/gl-prototypes/cogl-in-gles2-core-functions.h \
$(srcdir)/gl-prototypes/cogl-glsl-functions.h \
$(NULL)
Adds a NOP driver This adds a new "nop" driver that does nothing. This can be selected at runtime either with the COGL_DRIVER=nop environment variable or by passing COGL_DRIVER_NOP to cogl_renderer_set_driver() Adding the nop driver gives us a way to test workloads without any driver and hardware overheads which can help us understand how Cogl's state tracking performs in isolation. Having a nop driver can also serve as an shell/outline for creating other drivers later. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 90587418233b6438290741d80aedf193ae660cad)
2012-09-12 21:39:46 +00:00
cogl_driver_sources += \
Check for out-of-memory when allocating 2d textures This makes Cogl explicitly check for out-of-memory errors reported by the opengl driver in cogl_texture_2d_new_with_size() calls. This allows us to throw a COGL_SYSTEM_ERROR_NO_MEMORY error and return NULL so applications may gracefully handle this condition. This patch only affects the cogl_texture_2d_new_with_size() api not _new_from_data() or _new_from_bitmap(). Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 0283423dad59ba3d3e4cde400c29ac8e7803f888)
2012-10-25 15:56:14 +00:00
$(srcdir)/driver/gl/cogl-util-gl-private.h \
$(srcdir)/driver/gl/cogl-util-gl.c \
build: fix make dist (cherry picked from commit 6a78a8c6b6d368f2816f50e10cb9602f5c47de71)
2012-10-07 21:15:05 +00:00
$(srcdir)/driver/gl/cogl-framebuffer-gl-private.h \
Re-organize the source layout As part of an effort towards being able to write non-opengl based backends for Cogl this moves most of the opengl specific code under drivers/gl. drivers/gl and drivers/gles have been moved to drivers/gl/gl and drivers/gl/es respectively. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 7dc482facb0a265c7f48660079e7e12dd7a2813e)
2012-09-12 20:25:11 +00:00
$(srcdir)/driver/gl/cogl-framebuffer-gl.c \
moves some gl texture code too cogl-texture-gl.c This adds a driver/gl/cogl-texture-gl.c file and moves some gl specific bits from cogl-texture.c into it. The moved symbols were also given a _gl_ infix and the calling code was updated accordingly. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 2c9e81de70cc02d72b1ce9013c49e39300a05b6a)
2012-11-08 23:00:49 +00:00
$(srcdir)/driver/gl/cogl-texture-gl-private.h \
$(srcdir)/driver/gl/cogl-texture-gl.c \
texture-2d: factor out all GL specific code This factors out all of the OpenGL specific code in cogl-texture-2d.c into cogl-texture-2d-gl.c and where necessary adds indirection through the CoglDriver vtable so that we can eventually start to experiment with non-OpenGL backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit ec57588671696bbe7ce714bdfe7324236146c9c0)
2012-09-10 20:45:33 +00:00
$(srcdir)/driver/gl/cogl-texture-2d-gl-private.h \
$(srcdir)/driver/gl/cogl-texture-2d-gl.c \
attribute: Split out GL specific code As part of an on-going effort to enable non-opengl drivers for Cogl this splits out the GL specific code in cogl-attribute.c into cogl/driver/gl/cogl-attribute-gl.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 7e20c39c47fa176aa5062867ff273bc2c41a2f22)
2012-09-19 19:04:24 +00:00
$(srcdir)/driver/gl/cogl-attribute-gl-private.h \
$(srcdir)/driver/gl/cogl-attribute-gl.c \
clip-stack: Splits out opengl specific code As part of an on-going effort to enable non-opengl drivers for Cogl this splits out the opengl specific code in cogl-clip-stack.c into cogl/driver/cogl-clip-stack-gl.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit acf989f1bb628282c53d1249b2e3fc6f6579f1e9)
2012-09-19 19:37:32 +00:00
$(srcdir)/driver/gl/cogl-clip-stack-gl-private.h \
$(srcdir)/driver/gl/cogl-clip-stack-gl.c \
buffer: splits out GL specific code As part of an on-going effort to be able to support non-opengl drivers for Cogl this splits out the opengl specific code from cogl-buffer.c into driver/gl/cogl-buffer-gl.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 4d7094a979ff2cbbe4054f4a44ca05fc41a9e447)
2012-09-19 21:32:25 +00:00
$(srcdir)/driver/gl/cogl-buffer-gl-private.h \
$(srcdir)/driver/gl/cogl-buffer-gl.c \
Re-organize the source layout As part of an effort towards being able to write non-opengl based backends for Cogl this moves most of the opengl specific code under drivers/gl. drivers/gl and drivers/gles have been moved to drivers/gl/gl and drivers/gl/es respectively. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 7dc482facb0a265c7f48660079e7e12dd7a2813e)
2012-09-12 20:25:11 +00:00
$(srcdir)/driver/gl/cogl-pipeline-opengl.c \
$(srcdir)/driver/gl/cogl-pipeline-opengl-private.h \
$(srcdir)/driver/gl/cogl-pipeline-fragend-glsl.c \
$(srcdir)/driver/gl/cogl-pipeline-fragend-glsl-private.h \
$(srcdir)/driver/gl/gl/cogl-pipeline-fragend-arbfp.c \
$(srcdir)/driver/gl/gl/cogl-pipeline-fragend-arbfp-private.h \
Clearly define 3 progends that own the frag+vertends This adds a new "fixed-arbfp" progend so we now have 3 distinct ways of setting up the state of a pipeline: » fixed; where the vertex and fragment processing are implemented using fixed function opengl apis. » fixed-arbfp; where vertex processing is implemented using fixed function opengl apis but fragment processing is implemented using the ARB Fragment Processing language. » glsl; there vertex and fragment processing are both implemented using glsl. This means we avoid unusual, combinations such as glsl for vertex processing and arbfp for fragment processing, and also avoid pairing fixed-function vertex processing with glsl fragment processing which we happen to know hits some awkward code paths in Mesa that lead to poor performance. As part of this change, the progend now implies specific vertend and fragend choices so instead of associating a vertend and fragend with a pipeline we now just associate a progend choice. When flushing a pipeline and choosing what progend to use, we now call a progend->start() method that is able to determine if the vertend and fragend together will be able to handle the given pipeline so the vertend and fragend ->start() methods no longer need to return a boolean status. Since we now don't need to support glsl used in conjunction with fixed function this will allow us to avoid ever using OpenGL builtin attribute names, though this patch doesn't change that yet. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit cec381f50c7a2f2186bd4a8c5f38fecd5f099075)
2012-09-25 20:08:10 +00:00
$(srcdir)/driver/gl/gl/cogl-pipeline-progend-fixed-arbfp.c \
$(srcdir)/driver/gl/gl/cogl-pipeline-progend-fixed-arbfp-private.h \
Re-organize the source layout As part of an effort towards being able to write non-opengl based backends for Cogl this moves most of the opengl specific code under drivers/gl. drivers/gl and drivers/gles have been moved to drivers/gl/gl and drivers/gl/es respectively. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 7dc482facb0a265c7f48660079e7e12dd7a2813e)
2012-09-12 20:25:11 +00:00
$(srcdir)/driver/gl/cogl-pipeline-fragend-fixed.c \
$(srcdir)/driver/gl/cogl-pipeline-fragend-fixed-private.h \
$(srcdir)/driver/gl/cogl-pipeline-vertend-glsl.c \
$(srcdir)/driver/gl/cogl-pipeline-vertend-glsl-private.h \
$(srcdir)/driver/gl/cogl-pipeline-vertend-fixed.c \
$(srcdir)/driver/gl/cogl-pipeline-vertend-fixed-private.h \
$(srcdir)/driver/gl/cogl-pipeline-progend-fixed.c \
$(srcdir)/driver/gl/cogl-pipeline-progend-fixed-private.h \
$(srcdir)/driver/gl/cogl-pipeline-progend-glsl.c \
$(srcdir)/driver/gl/cogl-pipeline-progend-glsl-private.h \
$(NULL)
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 19:44:56 +00:00
if COGL_DRIVER_GL_SUPPORTED
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
cogl_driver_sources += \
Re-organize the source layout As part of an effort towards being able to write non-opengl based backends for Cogl this moves most of the opengl specific code under drivers/gl. drivers/gl and drivers/gles have been moved to drivers/gl/gl and drivers/gl/es respectively. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 7dc482facb0a265c7f48660079e7e12dd7a2813e)
2012-09-12 20:25:11 +00:00
$(srcdir)/driver/gl/gl/cogl-driver-gl.c \
$(srcdir)/driver/gl/gl/cogl-texture-driver-gl.c \
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
$(NULL)
endif
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 19:44:56 +00:00
if COGL_DRIVER_GLES_SUPPORTED
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
cogl_driver_sources += \
Re-organize the source layout As part of an effort towards being able to write non-opengl based backends for Cogl this moves most of the opengl specific code under drivers/gl. drivers/gl and drivers/gles have been moved to drivers/gl/gl and drivers/gl/es respectively. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 7dc482facb0a265c7f48660079e7e12dd7a2813e)
2012-09-12 20:25:11 +00:00
$(srcdir)/driver/gl/gles/cogl-driver-gles.c \
$(srcdir)/driver/gl/gles/cogl-texture-driver-gles.c \
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
$(NULL)
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 19:44:56 +00:00
endif
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
build: Do not build a noinst library for the tesselator Let's try to keep Cogl's build as non-recursive as possible, in the hope that one day we'll be able to make it fully non-recursive along with the rest of Clutter.
2010-09-12 18:25:47 +00:00
# winsys sources, common to all backends
cogl_winsys_common_sources = \
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 12:28:33 +00:00
$(srcdir)/winsys/cogl-winsys-private.h \
$(srcdir)/winsys/cogl-winsys.c \
build: Do not build a noinst library for the tesselator Let's try to keep Cogl's build as non-recursive as possible, in the hope that one day we'll be able to make it fully non-recursive along with the rest of Clutter.
2010-09-12 18:25:47 +00:00
$(NULL)
# tesselator sources
cogl_tesselator_sources = \
$(srcdir)/tesselator/dict-list.h \
$(srcdir)/tesselator/dict.c \
$(srcdir)/tesselator/dict.h \
$(srcdir)/tesselator/geom.c \
$(srcdir)/tesselator/geom.h \
$(srcdir)/tesselator/gluos.h \
$(srcdir)/tesselator/memalloc.h \
$(srcdir)/tesselator/mesh.c \
$(srcdir)/tesselator/mesh.h \
$(srcdir)/tesselator/normal.c \
$(srcdir)/tesselator/normal.h \
$(srcdir)/tesselator/priorityq-heap.h \
$(srcdir)/tesselator/priorityq-sort.h \
$(srcdir)/tesselator/priorityq.c \
$(srcdir)/tesselator/priorityq.h \
$(srcdir)/tesselator/render.c \
$(srcdir)/tesselator/render.h \
$(srcdir)/tesselator/sweep.c \
$(srcdir)/tesselator/sweep.h \
$(srcdir)/tesselator/tess.c \
$(srcdir)/tesselator/tess.h \
$(srcdir)/tesselator/tesselator.h \
$(srcdir)/tesselator/tessmono.c \
$(srcdir)/tesselator/tessmono.h \
$(srcdir)/tesselator/GL/glu.h \
$(NULL)
EXTRA_DIST += \
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
$(srcdir)/tesselator/README \
$(srcdir)/tesselator/priorityq-heap.c \
$(NULL)
build: Do not build a noinst library for the tesselator Let's try to keep Cogl's build as non-recursive as possible, in the hope that one day we'll be able to make it fully non-recursive along with the rest of Clutter.
2010-09-12 18:25:47 +00:00
# sources
build: Clean up COGL build flags
2010-01-13 15:40:36 +00:00
cogl_sources_c = \
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
$(cogl_driver_sources) \
build: Do not build a noinst library for the tesselator Let's try to keep Cogl's build as non-recursive as possible, in the hope that one day we'll be able to make it fully non-recursive along with the rest of Clutter.
2010-09-12 18:25:47 +00:00
$(cogl_winsys_common_sources) \
$(cogl_tesselator_sources) \
cogl: Don't flush the journal when flushing clip state Flushing the clip state no longer does anything that would cause the journal to flush. The clip state is only flushed when flushing the framebuffer state and in all cases this ends up flushing the journal in one way or another anyway. Avoiding flushing the journal will make it easier to log the clip state in the journal. Previously when trying to set up a rectangle clip that can't be scissored or when using a path clip the code would use cogl_rectangle as part of the process to fill the stencil buffer. This is now changed to use a new internal _cogl_rectangle_immediate function which directly uses the vertex array API to draw a triangle strip without affecting the journal. This should be just as efficient as the previous journalled code because these places would end up flushing the journal immediately before and after submitting the single rectangle anyway and flushing the journal always creates a new vbo so it would effectively do the same thing. Similarly there is also a new internal _cogl_clear function that does not flush the journal.
2010-11-02 17:15:06 +00:00
$(srcdir)/cogl-private.h \
cogl: don't include cogl-debug.h in cogl.h or install cogl-debug.h is an internal header so it shouldn't have been included by cogl.h and the header shouldn't be installed either.
2010-07-25 20:36:41 +00:00
$(srcdir)/cogl-debug.h \
build: Add cogl-debug-options.h
2010-09-15 14:56:42 +00:00
$(srcdir)/cogl-debug-options.h \
Add a mechanism for determining GPU driver details This adds a CoglGpuInfo struct to the CoglContext which contains some enums describing the GL driver in use. This currently includes the driver package (ie, is it Mesa) the version number of the package and the vendor of the GPU (ie, is it by Intel). There is also a bitmask which will contain the workarounds that we should do for that particular driver configuration. The struct is initialised on context creation by using a series of string comparisons on the strings returned from glGetString. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-27 13:43:04 +00:00
$(srcdir)/cogl-gpu-info.c \
$(srcdir)/cogl-gpu-info-private.h \
cogl: rename cogl-context.h cogl-context-private.h Since we plan to add public cogl_context_* API we need to rename the current cogl-context.h which contains private member details.
2010-11-04 22:25:52 +00:00
$(srcdir)/cogl-context-private.h \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-context.c \
Adds renderer,display,onscreen-template and swap-chain stubs As part of the process of splitting Cogl out as a standalone graphics API we need to introduce some API concepts that will allow us to initialize a new CoglContext when Clutter isn't there to handle that for us... The new objects roughly in the order that they are (optionally) involved in constructing a context are: CoglRenderer, CoglOnscreenTemplate, CoglSwapChain and CoglDisplay. Conceptually a CoglRenderer represents a means for rendering. Cogl supports rendering via OpenGL or OpenGL ES 1/2.0 and those APIs are accessed through a number of different windowing APIs such as GLX, EGL, SDL or WGL and more. Potentially in the future Cogl could render using D3D or even by using libdrm and directly banging the hardware. All these choices are wrapped up in the configuration of a CoglRenderer. Conceptually a CoglDisplay represents a display pipeline for a renderer. Although Cogl doesn't aim to provide a detailed abstraction of display hardware, on some platforms we can give control over multiple display planes (On TV platforms for instance video content may be on one plane and 3D would be on another so a CoglDisplay lets you select the plane up-front.) Another aspect of CoglDisplay is that it lets us negotiate a display pipeline that best supports the type of CoglOnscreen framebuffers we are planning to create. For instance if you want transparent CoglOnscreen framebuffers then we have to be sure the display pipeline wont discard the alpha component of your framebuffers. Or if you want to use double/tripple buffering that requires support from the display pipeline. CoglOnscreenTemplate and CoglSwapChain are how we describe our default CoglOnscreen framebuffer configuration which can affect the configuration of the display pipeline. The default/simple way we expect most CoglContexts to be constructed will be via something like: if (!cogl_context_new (NULL, &error)) g_error ("Failed to construct a CoglContext: %s", error->message); Where that NULL is for an optional "display" parameter and NULL says to Cogl "please just try to do something sensible". If you want some more control though you can manually construct a CoglDisplay something like: display = cogl_display_new (NULL, NULL); cogl_gdl_display_set_plane (display, plane); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message); And in a similar fashion to cogl_context_new() you can optionally pass a NULL "renderer" and/or a NULL "onscreen template" so Cogl will try to just do something sensible. If you need to change the CoglOnscreen defaults you can provide a template something like: chain = cogl_swap_chain_new (); cogl_swap_chain_set_has_alpha (chain, TRUE); cogl_swap_chain_set_length (chain, 3); onscreen_template = cogl_onscreen_template_new (chain); cogl_onscreen_template_set_pixel_format (onscreen_template, COGL_PIXEL_FORMAT_RGB565); display = cogl_display_new (NULL, onscreen_template); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message);
2011-02-25 17:06:50 +00:00
$(srcdir)/cogl-renderer-private.h \
$(srcdir)/cogl-renderer.h \
$(srcdir)/cogl-renderer.c \
$(srcdir)/cogl-swap-chain-private.h \
$(srcdir)/cogl-swap-chain.h \
$(srcdir)/cogl-swap-chain.c \
$(srcdir)/cogl-onscreen-template-private.h \
$(srcdir)/cogl-onscreen-template.h \
$(srcdir)/cogl-onscreen-template.c \
$(srcdir)/cogl-display-private.h \
$(srcdir)/cogl-display.h \
$(srcdir)/cogl-display.c \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-internal.h \
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 16:32:56 +00:00
$(srcdir)/cogl-driver.h \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl.c \
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 21:24:56 +00:00
$(srcdir)/cogl-object-private.h \
$(srcdir)/cogl-object.h \
$(srcdir)/cogl-object.c \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-util.h \
$(srcdir)/cogl-util.c \
$(srcdir)/cogl-bitmap-private.h \
$(srcdir)/cogl-bitmap.c \
bitmap: Remove the split between 'image library' and 'fallback' Previously the bitmap code was setup so that there could be an image library used to convert between formats and then some 'fallback' code when the image library can't handle the conversion. However there was never any implementation of the conversion in the image library so the fallback was always used. I don't think this split really makes sense so this patch renames cogl-bitmap-fallback to cogl-bitmap-conversion and removes the stub conversion functions in the image library. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-01 13:14:10 +00:00
$(srcdir)/cogl-bitmap-conversion.c \
build: list cogl-bitmap-packing.h as source file This fixes make release-check because cogl-bitmap-packing.h wasn't being packaged.
2012-03-05 23:18:08 +00:00
$(srcdir)/cogl-bitmap-packing.h \
cogl: Don't flush the journal when flushing clip state Flushing the clip state no longer does anything that would cause the journal to flush. The clip state is only flushed when flushing the framebuffer state and in all cases this ends up flushing the journal in one way or another anyway. Avoiding flushing the journal will make it easier to log the clip state in the journal. Previously when trying to set up a rectangle clip that can't be scissored or when using a path clip the code would use cogl_rectangle as part of the process to fill the stencil buffer. This is now changed to use a new internal _cogl_rectangle_immediate function which directly uses the vertex array API to draw a triangle strip without affecting the journal. This should be just as efficient as the previous journalled code because these places would end up flushing the journal immediately before and after submitting the single rectangle anyway and flushing the journal always creates a new vbo so it would effectively do the same thing. Similarly there is also a new internal _cogl_clear function that does not flush the journal.
2010-11-02 17:15:06 +00:00
$(srcdir)/cogl-primitives-private.h \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-primitives.h \
$(srcdir)/cogl-primitives.c \
build: Add a missing file
2010-11-19 18:29:43 +00:00
$(srcdir)/cogl-path-private.h \
cogl: cleanly separate primitives + paths code The function prototypes for the primitives API were spread between cogl-path.h and cogl-texture.h and should have been in a cogl-primitives.h. As well as shuffling the prototypes around into more sensible places this commit splits the cogl-path API out from cogl-primitives.c into a cogl-path.c
2010-02-10 22:30:37 +00:00
$(srcdir)/cogl-path.h \
$(srcdir)/cogl-path.c \
path 2.0: update path API for experimental 2.0 API When COGL_ENABLE_EXPERIMENTAL_2_0_API is defined cogl.h will now include cogl2-path.h which changes cogl_path_new() so it can directly return a CoglPath pointer; it no longer exposes a prototype for cogl_{get,set}_path and all the remaining cogl_path_ functions now take an explicit path as their first argument. The idea is that we want to encourage developers to retain path objects for as long as possible so they can take advantage of us uploading the path geometry to the GPU. Currently although it is possible to start a new path and query the current path, it is not convenient. The other thing is that we want to get Cogl to the point where nothing depends on a global, current context variable. This will allow us to one day define a sensible threading model if/when that is ever desired.
2010-11-04 00:27:47 +00:00
$(srcdir)/cogl2-path.h \
$(srcdir)/cogl2-path.c \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-bitmap-pixbuf.c \
$(srcdir)/cogl-clip-stack.h \
$(srcdir)/cogl-clip-stack.c \
cogl-clip-state: Adapt to experimental cogl2 API. The current clip state implementation couldn't be used in conjunction with the CoglPath experimental API. http://bugzilla.clutter-project.org/show_bug.cgi?id=2594 Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-03-02 17:45:25 +00:00
$(srcdir)/cogl-clip-state-private.h \
$(srcdir)/cogl-clip-state.h \
$(srcdir)/cogl-clip-state.c \
Add compatibility API for functions removed after 1.9.8 The cleanup in 185630085 removed some symbols that were previously exported as public experimental API in Cogl 1.9.8. That release is already well after the point where we were meant to freeze the ABI so we probably shouldn't be breaking it again. This patch adds the removed functions back in so that for 1.9.10 we won't have to bump the soname. The symbols are bundled together in a new file called cogl2-compatibility.c so that they will be easy to remove again after we can break ABI. It is expected that we will revert this patch immediately after branching for Cogl 1.10. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-09 16:09:13 +00:00
$(srcdir)/cogl2-compatibility.c \
cogl: Make it easier to add checks for GL extensions Previously if you need to depend on a new GL feature you had to: - Add typedefs for all of the functions in cogl-defines.h.in - Add function pointers for each of the functions in cogl-context-driver.h - Add an initializer for the function pointers in cogl-context-driver.c - Add a check for the extension and all of the functions in cogl_features_init. If the extension is available under multiple names then you have to duplicate the checks. This is quite tedious and error prone. This patch moves all of the features and their functions into a list of macro invocations in cogl-feature-functions.h. The macros can be redefined to implement all of the above tasks from the same header. The features are described in a struct with a pointer to a table of functions. A new function takes the feature description from this struct and checks for its availability. The feature can take a list of extension names with a list of alternate namespaces (such as "EXT" or "ARB"). It can also detect the feature from a particular version of GL. The typedefs are now gone and instead the function pointer in the Cogl context just directly contains the type. Some of the functions in the context were previously declared with the 'ARB' extension. This has been removed so that now all the functions have no suffix. This makes more sense when the extension could potentially be merged into GL core as well.
2009-11-17 13:52:40 +00:00
$(srcdir)/cogl-feature-private.h \
$(srcdir)/cogl-feature-private.c \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-fixed.c \
build: Fix a compiler warning when using make dist Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2010-06-15 21:36:19 +00:00
$(srcdir)/cogl-color-private.h \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-color.c \
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
$(srcdir)/cogl-buffer-private.h \
$(srcdir)/cogl-buffer.c \
Rename CoglPixelArray to CoglPixelBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to strongly imply a relationship between CoglBuffers and CoglPixelBuffers and be consistent with the CoglAttributeBuffer and CoglIndexBuffer APIs.
2011-03-02 15:19:57 +00:00
$(srcdir)/cogl-pixel-buffer-private.h \
$(srcdir)/cogl-pixel-buffer.c \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-vertex-buffer-private.h \
$(srcdir)/cogl-vertex-buffer.c \
Rename CoglIndexArray to CoglIndexBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to strongly imply a relationship between CoglBuffers and CoglIndexBuffers and be consistent with the CoglAttributeBuffer and CoglPixelBuffer APIs.
2011-03-02 23:31:19 +00:00
$(srcdir)/cogl-index-buffer-private.h \
$(srcdir)/cogl-index-buffer.c \
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
$(srcdir)/cogl-attribute-buffer-private.h \
$(srcdir)/cogl-attribute-buffer.c \
cogl: Adds experimental CoglIndices API CoglIndices define a range of indices inside a CoglIndexArray. I.e. a CoglIndexArray is simply a buffer of N bytes and you can then instantiate multiple CoglIndices collections that define a sub-region of a CoglIndexArray by specifying a start offset and an index data type.
2010-10-12 11:48:58 +00:00
$(srcdir)/cogl-indices-private.h \
$(srcdir)/cogl-indices.c \
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
$(srcdir)/cogl-attribute-private.h \
$(srcdir)/cogl-attribute.c \
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
$(srcdir)/cogl-primitive-private.h \
$(srcdir)/cogl-primitive.c \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-matrix.c \
math: Adds an experimental cogl_vector3_* API This adds a math utility API for handling 3 component, single precision float vectors with the following; mostly self explanatory functions: cogl_vector3_init cogl_vector3_init_zero cogl_vector3_equal cogl_vector3_equal_with_epsilon cogl_vector3_copy cogl_vector3_free cogl_vector3_invert cogl_vector3_add cogl_vector3_subtract cogl_vector3_multiply_scalar cogl_vector3_divide_scalar cogl_vector3_normalize cogl_vector3_magnitude cogl_vector3_cross_product cogl_vector3_dot_product cogl_vector3_distance Since the API is experimental you will need to define COGL_ENABLE_EXPERIMENTAL_API before including cogl.h if you want to use the API.
2010-05-20 13:54:44 +00:00
$(srcdir)/cogl-vector.c \
math: Adds an experimental euler API This adds an experimental CoglEuler data type and the following new functions: cogl_euler_init cogl_euler_init_from_matrix cogl_euler_init_from_quaternion cogl_euler_equal cogl_euler_copy cogl_euler_free cogl_quaternion_init_from_euler Since this is experimental API you need to define COGL_ENABLE_EXPERIMENTAL_API before including cogl.h
2010-02-25 01:40:29 +00:00
$(srcdir)/cogl-euler.c \
Fixes for make distcheck
2011-06-13 11:42:25 +00:00
$(srcdir)/cogl-quaternion-private.h \
math: Adds an experimental quaternion API This adds an experimental quaternion utility API. It's not yet fully documented but it's complete enough that people can start to experiment with using it. It adds the following functions: cogl_quaternion_init_identity cogl_quaternion_init cogl_quaternion_init_from_angle_vector cogl_quaternion_init_from_array cogl_quaternion_init_from_x_rotation cogl_quaternion_init_from_y_rotation cogl_quaternion_init_from_z_rotation cogl_quaternion_equal cogl_quaternion_copy cogl_quaternion_free cogl_quaternion_get_rotation_angle cogl_quaternion_get_rotation_axis cogl_quaternion_normalize cogl_quaternion_dot_product cogl_quaternion_invert cogl_quaternion_multiply cogl_quaternion_pow cogl_quaternion_slerp cogl_quaternion_nlerp cogl_quaternion_squad cogl_get_static_identity_quaternion cogl_get_static_zero_quaternion Since it's experimental API you'll need to define COGL_ENABLE_EXPERIMENTAL_API before including cogl.h.
2010-02-25 01:40:29 +00:00
$(srcdir)/cogl-quaternion.c \
build: Add cogl-matrix-private.h to the dist
2009-11-18 14:37:43 +00:00
$(srcdir)/cogl-matrix-private.h \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-matrix-stack.c \
$(srcdir)/cogl-matrix-stack.h \
Add CoglDepthState API Instead of simply extending the cogl_pipeline_ namespace to add api for controlling the depth testing state we now break the api out. This adds a CoglDepthState type that can be stack allocated. The members of the structure are private but we have the following API to setup the state: cogl_depth_state_init cogl_depth_state_set_test_enabled cogl_depth_state_get_test_enabled cogl_depth_state_set_test_function cogl_depth_state_get_test_function cogl_depth_state_set_writing_enabled cogl_depth_state_get_writing_enabled cogl_depth_state_set_range cogl_depth_state_get_range This removes the following experimental API which is now superseded: cogl_material_set_depth_test_enabled cogl_material_get_depth_test_enabled cogl_material_set_depth_test_function cogl_material_get_depth_test_function cogl_material_set_depth_writing_enabled cogl_material_get_depth_writing_enabled cogl_material_set_depth_range cogl_material_get_depth_range Once a CoglDepthState structure is setup it can be set on a pipeline using cogl_pipeline_set_depth_state().
2011-04-14 17:12:03 +00:00
$(srcdir)/cogl-depth-state.c \
$(srcdir)/cogl-depth-state-private.h \
pipeline: Split more code out from cogl-pipeline.c This splits out the core CoglPipelineLayer support code from cogl-pipeline.c into cogl-pipeline-layer.c; it splits out the debugging code for dumping a pipeline to a .dot file into cogl-pipeline-debug.c and it splits the CoglPipelineNode support which is shared between CoglPipeline and CoglPipelineLayer into cogl-node.c. Note: cogl-pipeline-layer.c only contains the layer code directly relating to CoglPipelineLayer objects; it does not contain any _cogl_pipeline API relating to how CoglPipeline tracks and manipulates layers.
2011-09-08 23:40:06 +00:00
$(srcdir)/cogl-node.c \
$(srcdir)/cogl-node-private.h \
cogl: rename CoglMaterial -> CoglPipeline This applies an API naming change that's been deliberated over for a while now which is to rename CoglMaterial to CoglPipeline. For now the new pipeline API is marked as experimental and public headers continue to talk about materials not pipelines. The CoglMaterial API is now maintained in terms of the cogl_pipeline API internally. Currently this API is targeting Cogl 2.0 so we will have time to integrate it properly with other upcoming Cogl 2.0 work. The basic reasons for the rename are: - That the term "material" implies to many people that they are constrained to fragment processing; perhaps as some kind of high-level texture abstraction. - In Clutter they get exposed by ClutterTexture actors which may be re-inforcing this misconception. - When comparing how other frameworks use the term material, a material sometimes describes a multi-pass fragment processing technique which isn't the case in Cogl. - In code, "CoglPipeline" will hopefully be a much more self documenting summary of what these objects represent; a full GPU pipeline configuration including, for example, vertex processing, fragment processing and blending. - When considering the API documentation story, at some point we need a document introducing developers to how the "GPU pipeline" works so it should become intuitive that CoglPipeline maps back to that description of the GPU pipeline. - This is consistent in terminology and concept to OpenGL 4's new pipeline object which is a container for program objects. Note: The cogl-material.[ch] files have been renamed to cogl-material-compat.[ch] because otherwise git doesn't seem to treat the change as a moving the old cogl-material.c->cogl-pipeline.c and so we loose all our git-blame history.
2010-10-27 17:54:57 +00:00
$(srcdir)/cogl-pipeline.c \
$(srcdir)/cogl-pipeline-private.h \
pipeline: Split more code out from cogl-pipeline.c This splits out the core CoglPipelineLayer support code from cogl-pipeline.c into cogl-pipeline-layer.c; it splits out the debugging code for dumping a pipeline to a .dot file into cogl-pipeline-debug.c and it splits the CoglPipelineNode support which is shared between CoglPipeline and CoglPipelineLayer into cogl-node.c. Note: cogl-pipeline-layer.c only contains the layer code directly relating to CoglPipelineLayer objects; it does not contain any _cogl_pipeline API relating to how CoglPipeline tracks and manipulates layers.
2011-09-08 23:40:06 +00:00
$(srcdir)/cogl-pipeline-layer.c \
$(srcdir)/cogl-pipeline-layer-private.h \
pipeline: split out all core state apis Since cogl-pipeline.c has become very unwieldy this make a start at trying to shape this code back into a manageable state. This patche moves all the API relating to core pipeline state into cogl-pipeline-state.c. This doesn't move code relating to layer state out nor does it move any of the code supporting the core design of CoglPipeline itself. This change alone factors out 2k lines of code from cogl-pipeline.c which is obviously a good start. The next step will be to factor out the layer state and then probably look at breaking all of this state code down into state-groups. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-07 22:44:37 +00:00
$(srcdir)/cogl-pipeline-state.c \
pipeline: split out all layer state apis As part of an on-going effort to get cogl-pipeline.c into a more maintainable state this splits out all the apis relating just to layer state. This just leaves code relating to the core CoglPipeline and CoglPipelineLayer design left in cogl-pipeline.c. This splits out around 2k more lines from cogl-pipeline.c although we are still left with nearly 4k lines so we still have some way to go! Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-07 23:42:22 +00:00
$(srcdir)/cogl-pipeline-layer-state-private.h \
$(srcdir)/cogl-pipeline-layer-state.c \
pipeline: split out all core state apis Since cogl-pipeline.c has become very unwieldy this make a start at trying to shape this code back into a manageable state. This patche moves all the API relating to core pipeline state into cogl-pipeline-state.c. This doesn't move code relating to layer state out nor does it move any of the code supporting the core design of CoglPipeline itself. This change alone factors out 2k lines of code from cogl-pipeline.c which is obviously a good start. The next step will be to factor out the layer state and then probably look at breaking all of this state code down into state-groups. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-07 22:44:37 +00:00
$(srcdir)/cogl-pipeline-state-private.h \
pipeline: Split more code out from cogl-pipeline.c This splits out the core CoglPipelineLayer support code from cogl-pipeline.c into cogl-pipeline-layer.c; it splits out the debugging code for dumping a pipeline to a .dot file into cogl-pipeline-debug.c and it splits the CoglPipelineNode support which is shared between CoglPipeline and CoglPipelineLayer into cogl-node.c. Note: cogl-pipeline-layer.c only contains the layer code directly relating to CoglPipelineLayer objects; it does not contain any _cogl_pipeline API relating to how CoglPipeline tracks and manipulates layers.
2011-09-08 23:40:06 +00:00
$(srcdir)/cogl-pipeline-debug.c \
add cogl-glsl-shader files to aid backporting patches To aid with backporting patches from master made after the deprecated CoglShader api was removed this patch adds the cogl-glsl- files that have been added on master so we should get less conflicts when cherry picking.
2013-01-07 19:16:11 +00:00
$(srcdir)/cogl-glsl-shader.c \
$(srcdir)/cogl-glsl-shader-private.h \
$(srcdir)/cogl-glsl-shader-boilerplate.h \
pipeline: Move the snippet source loop into a common function The two loops that generate the functions for the snippets in the fragend and vertend are very similar so to avoid code duplication this patch moves the logic to its own function in a new cogl-pipeline-snippet.c file. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-25 15:31:21 +00:00
$(srcdir)/cogl-pipeline-snippet-private.h \
$(srcdir)/cogl-pipeline-snippet.c \
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 14:55:56 +00:00
$(srcdir)/cogl-pipeline-cache.h \
$(srcdir)/cogl-pipeline-cache.c \
cogl: rename CoglMaterial -> CoglPipeline This applies an API naming change that's been deliberated over for a while now which is to rename CoglMaterial to CoglPipeline. For now the new pipeline API is marked as experimental and public headers continue to talk about materials not pipelines. The CoglMaterial API is now maintained in terms of the cogl_pipeline API internally. Currently this API is targeting Cogl 2.0 so we will have time to integrate it properly with other upcoming Cogl 2.0 work. The basic reasons for the rename are: - That the term "material" implies to many people that they are constrained to fragment processing; perhaps as some kind of high-level texture abstraction. - In Clutter they get exposed by ClutterTexture actors which may be re-inforcing this misconception. - When comparing how other frameworks use the term material, a material sometimes describes a multi-pass fragment processing technique which isn't the case in Cogl. - In code, "CoglPipeline" will hopefully be a much more self documenting summary of what these objects represent; a full GPU pipeline configuration including, for example, vertex processing, fragment processing and blending. - When considering the API documentation story, at some point we need a document introducing developers to how the "GPU pipeline" works so it should become intuitive that CoglPipeline maps back to that description of the GPU pipeline. - This is consistent in terminology and concept to OpenGL 4's new pipeline object which is a container for program objects. Note: The cogl-material.[ch] files have been renamed to cogl-material-compat.[ch] because otherwise git doesn't seem to treat the change as a moving the old cogl-material.c->cogl-pipeline.c and so we loose all our git-blame history.
2010-10-27 17:54:57 +00:00
$(srcdir)/cogl-material-compat.c \
Merge cogl-program-{gl,gles}.c into one cogl-program.c This merges the two implementations of CoglProgram for the GLES2 and GL backends into one. The implementation is more like the GLES2 version which would track the uniform values and delay sending them to GL. CoglProgram is now effectively just a GList of CoglShaders along with an array of stored uniform values. CoglProgram never actually creates a GL program, instead this is left up to the GLSL material backend. This is necessary on GLES2 where we may need to relink the user's program with different generated shaders depending on the other emulated fixed function state. It will also be necessary in the future GLSL backends for regular OpenGL. The GLSL and ARBfp material backends are now the ones that create and link the GL program from the list of shaders. The linked program is attached to the private material state so that it can be reused if the CoglProgram is used again with the same material. This does mean the program will get relinked if the shader is used with multiple materials. This will be particularly bad if the legacy cogl_program_use function is used because that effectively always makes one-shot materials. This problem will hopefully be alleviated if we make a hash table with a cache of generated programs. The cogl program would then need to become part of the hash lookup. Each CoglProgram now has an age counter which is incremented every time a shader is added. This is used by the material backends to detect when we need to create a new GL program for the user program. The internal _cogl_use_program function now takes a GL program handle rather than a CoglProgram. It no longer needs any special differences for GLES2. The GLES2 wrapper function now also uses this function to bind its generated shaders. The ARBfp shaders no longer store a copy of the program source but instead just directly create a program object when cogl_shader_source is called. This avoids having to reupload the source if the same shader is used in multiple materials. There are currently a few gross hacks to get the GLES2 backend to work with this. The problem is that the GLSL material backend is now generating a complete GL program but the GLES2 wrapper still needs to add its fixed function emulation shaders if the program doesn't provide either a vertex or fragment shader. There is a new function in the GLES2 wrapper called _cogl_gles2_use_program which replaces the previous cogl_program_use implementation. It extracts the GL shaders from the GL program object and creates a new GL program containing all of the shaders plus its fixed function emulation. This new program is returned to the GLSL material backend so that it can still flush the custom uniforms using it. The user_program is attached to the GLES2 settings struct as before but its stored using a GL program handle rather than a CoglProgram pointer. This hack will go away once the GLSL material backend replaces the GLES2 wrapper by generating the code itself. Under Mesa this currently generates some GL errors when glClear is called in test-cogl-shader-glsl. I think this is due to a bug in Mesa however. When the user program on the material is changed the GLSL backend gets notified and deletes the GL program that it linked from the user shaders. The program will still be bound in GL however. Leaving a deleted shader bound exposes a bug in Mesa's glClear implementation. More details are here: https://bugs.freedesktop.org/show_bug.cgi?id=31194
2010-10-15 17:00:29 +00:00
$(srcdir)/cogl-program.c \
$(srcdir)/cogl-program-private.h \
Use GL_ARB_sampler_objects GL_ARB_sampler_objects provides a GL object which overrides the sampler state part of a texture object with different values. The sampler state that Cogl currently exposes is the wrap modes and filters. Cogl exposes the state as part of the pipeline layer state but without this extension GL only exposes it as part of the texture object state. This means that it won't work to use a single texture multiple times in one primitive with different sampler states. It also makes switching between different sampler states with a single texture not terribly efficient because it has to change the texture object state every time. This patch adds a cache for sampler states in a shared hash table attached to the CoglContext. The entire set of parameters for the sampler state is used as the key for the hash table. When a unique state is encountered the sampler cache will create a new entry, otherwise it will return a const pointer to an existing entry. That means we can have a single pointer to represent any combination of sampler state. Pipeline layers now just store this single pointer rather than storing all of the sampler state. The two separate state flags for wrap modes and filters have now been combined into one. It should be faster to compare the sampler state now because instead of comparing each value it can just compare the pointers to the cached sampler entries. The hash table of cached sampler states should only need to perform its more expensive hash on the state when a property is changed on a pipeline, not every time it is flushed. When the sampler objects extension is available each cached sampler state will also get a sampler object to represent it. The common code to flush the GL state will now simply bind this object to a unit instead of flushing the state though the CoglTexture when possible. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 21:20:04 +00:00
$(srcdir)/cogl-sampler-cache.c \
$(srcdir)/cogl-sampler-cache-private.h \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-blend-string.c \
$(srcdir)/cogl-blend-string.h \
$(srcdir)/cogl-debug.c \
cogl: Add a sub texture backend This adds a new texture backend which represents a sub texture of a larger texture. The texture is created with a reference to the full texture and a set of coordinates describing the region. The backend simply defers to the full texture for all operations and maps the coordinates to the other range. You can also use coordinates outside the range [0,1] to create a repeated version of the full texture. A new public API function called cogl_texture_new_from_sub_texture is available to create the sub texture.
2009-11-27 16:39:16 +00:00
$(srcdir)/cogl-sub-texture-private.h \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-texture-private.h \
cogl: Add a CoglTexture2D backend This is an optimised version of CoglTexture2DSliced that always deals with a single texture and always uses the GL_TEXTURE_2D target. cogl_texture_new_from_bitmap now tries to use this backend first. If it can't create a texture with that size then it falls back the sliced backend. cogl_texture_upload_data_prepare has been split into two functions because the sliced backend needs to know the real internal format before the conversion is performed. Otherwise the converted bitmap will be wasted if the backend can't support the size.
2009-11-27 18:45:36 +00:00
$(srcdir)/cogl-texture-2d-private.h \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-texture-2d-sliced-private.h \
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 21:04:59 +00:00
$(srcdir)/cogl-texture-3d-private.h \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-texture-driver.h \
cogl: Add a sub texture backend This adds a new texture backend which represents a sub texture of a larger texture. The texture is created with a reference to the full texture and a set of coordinates describing the region. The backend simply defers to the full texture for all operations and maps the coordinates to the other range. You can also use coordinates outside the range [0,1] to create a repeated version of the full texture. A new public API function called cogl_texture_new_from_sub_texture is available to create the sub texture.
2009-11-27 16:39:16 +00:00
$(srcdir)/cogl-sub-texture.c \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-texture.c \
texture: split out high-level texture constructors This splits out the very high level texture constructors that may internally construct one of several types of lower level texture due to various constraints. This also updates the prototypes for these constructors to take an explicit context pointer and return a CoglError consistent with other texture constructors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit a1cabfae6ad50c51006c608cdde7d631b7832e71)
2012-11-08 20:33:00 +00:00
$(srcdir)/cogl-auto-texture.c \
cogl: Add a CoglTexture2D backend This is an optimised version of CoglTexture2DSliced that always deals with a single texture and always uses the GL_TEXTURE_2D target. cogl_texture_new_from_bitmap now tries to use this backend first. If it can't create a texture with that size then it falls back the sliced backend. cogl_texture_upload_data_prepare has been split into two functions because the sliced backend needs to know the real internal format before the conversion is performed. Otherwise the converted bitmap will be wasted if the backend can't support the size.
2009-11-27 18:45:36 +00:00
$(srcdir)/cogl-texture-2d.c \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-texture-2d-sliced.c \
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 21:04:59 +00:00
$(srcdir)/cogl-texture-3d.c \
cogl: Add an internal CoglTextureRectangle backend This adds an internal rectangle texture backend which is mostly based on the CoglTexture2D backend. It will throw assert failures if any operations are attempted that rectangle textures don't support, such as mipmapping or hardware repeating.
2010-06-10 14:33:34 +00:00
$(srcdir)/cogl-texture-rectangle-private.h \
$(srcdir)/cogl-texture-rectangle.c \
cogl-atlas: Rename to CoglRectangleMap This simply renames CoglAtlas to CoglRectangleMap without making any functional changes. The old 'CoglAtlas' is just a data structure for managing unused areas of a rectangle and it doesn't neccessarily have to be used for an atlas so it wasn't a very good name.
2010-08-02 14:24:03 +00:00
$(srcdir)/cogl-rectangle-map.h \
$(srcdir)/cogl-rectangle-map.c \
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 15:29:10 +00:00
$(srcdir)/cogl-atlas.h \
$(srcdir)/cogl-atlas.c \
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 13:06:32 +00:00
$(srcdir)/cogl-atlas-texture-private.h \
$(srcdir)/cogl-atlas-texture.c \
meta-texture: This publicly exposes CoglMetaTexture CoglMetaTexture is an interface for dealing with high level textures that may be comprised of one or more low-level textures internally. The interface allows the development of primitive drawing APIs that can draw with high-level textures (such as atlas textures) even though the GPU doesn't natively understand these texture types. There is currently just one function that's part of this interface: cogl_meta_texture_foreach_in_region() which allows an application to resolve the internal, low-level textures of a high-level texture. cogl_rectangle() uses this API for example so that it can easily emulate the _REPEAT wrap mode for textures that the hardware can't natively handle repeating of. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 13:13:03 +00:00
$(srcdir)/cogl-meta-texture.c \
Add a CoglPrimitiveTexture interface This interface represents any textures that are backed by a single texture in GL and that can be used directly with the cogl_framebuffer_draw_attributes family of functions. This currently equates to CoglTexture2D, CoglTexture3D and CoglTextureRectangle. The interface currently has only one method called cogl_primitive_set_auto_mipmap. This replaces the COGL_TEXTURE_NO_AUTO_MIPMAP flag from the CoglTextureFlags parameter in the constructors. None of the other flags in CoglTextureFlags make sense for primitive textures so it doesn't seem like a good idea to need them for primitive constructors. There is a boolean in the vtable to mark whether a texture type is primitive which the new cogl_is_primitive function uses. There is also a new texture virtual called set_auto_mipmap which is only required to be implemented for primitive textures. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 14:09:43 +00:00
$(srcdir)/cogl-primitive-texture.c \
cogl-atlas: Try 4 different approaches for migrating textures Instead of directly banging GL to migrate textures the atlas now uses the CoglFramebuffer API. It will use one of four approaches; it can set up two FBOs and use _cogl_blit_framebuffer to copy between them; it can use a single target fbo and then render the source texture to the FBO using a Cogl draw call; it can use a single FBO and call glCopyTexSubImage2D; or it can fallback to reading all of the texture data back to system memory and uploading it again with a sub texture update. Previously GL calls were used directly because Cogl wasn't able to create a framebuffer without a stencil and depth buffer. However there is now an internal version of cogl_offscreen_new_to_texture which takes a set of flags to disable the two buffers. The code for blitting has now been moved into a separate file called cogl-blit.c because it has become quite long and it may be useful outside of the atlas at some point. The 4 different methods have a fixed order of preference which is: * Texture render between two FBOs * glBlitFramebuffer * glCopyTexSubImage2D * glGetTexImage + glTexSubImage2D Once a method is succesfully used it is tried first for all subsequent blits. The default default can be overridden by setting the environment variable COGL_ATLAS_DEFAULT_BLIT_MODE to one of the following values: * texture-render * framebuffer * copy-tex-sub-image * get-tex-data
2011-01-20 17:45:47 +00:00
$(srcdir)/cogl-blit.h \
$(srcdir)/cogl-blit.c \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-spans.h \
$(srcdir)/cogl-spans.c \
$(srcdir)/cogl-journal-private.h \
$(srcdir)/cogl-journal.c \
cogl: deprecate cogl_draw_buffer API and replace with a cogl_framebuffer API cogl_push_draw_buffer, cogl_set_draw_buffer and cogl_pop_draw_buffer are now deprecated and new code should use the new cogl_framebuffer_* API instead. Code that previously did: cogl_push_draw_buffer (); cogl_set_draw_buffer (COGL_OFFSCREEN_BUFFER, buffer); /* draw */ cogl_pop_draw_buffer (); should now be re-written as: cogl_push_framebuffer (buffer); /* draw */ cogl_pop_framebuffer (); As can be seen from the example above the rename has been used as an opportunity to remove the redundant target argument from cogl_set_draw_buffer; it now only takes one call to redirect to an offscreen buffer, and finally the term framebuffer may be a bit more familiar to anyone coming from an OpenGL background.
2009-11-26 19:06:35 +00:00
$(srcdir)/cogl-framebuffer-private.h \
$(srcdir)/cogl-framebuffer.c \
build: add missing header to fix make dist
2011-11-02 11:34:26 +00:00
$(srcdir)/cogl-onscreen-private.h \
framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 20:31:04 +00:00
$(srcdir)/cogl-onscreen.c \
profiling: Adds initial UProf accounting to Cogl This adds gives Cogl a dedicated UProf context which will be linked together with Clutter's context during clutter_init_real(). Initial timers cover _cogl_journal_flush and _cogl_journal_log_quad You can explicitly ask for a report of Cogl statistics by exporting COGL_PROFILE_OUTPUT_REPORT=1 but since the context is linked with Clutter's the statisitcs will also be shown in the automatic Clutter reports.
2009-07-03 15:22:35 +00:00
$(srcdir)/cogl-profile.h \
$(srcdir)/cogl-profile.c \
cogl-context: Store winsys features in an array of unsigned ints Previously the mask of available winsys features was stored in a CoglBitmask. That isn't the ideal type to use for this because it is intended for a growable array of bits so it can allocate extra memory if there are more than 31 flags set. For the winsys feature flags the highest used bit is known at compile time so it makes sense to allocate a fixed array instead. This is conceptually similar to the CoglDebugFlags which are stored in an array of integers with macros to test a bit in the array. This moves the macros used for CoglDebugFlags to cogl-flags.h and makes them more generic so they can be shared with CoglContext.
2011-04-15 14:39:14 +00:00
$(srcdir)/cogl-flags.h \
cogl: Add an internal CoglBitmask type This implements a growable array of bits called CoglBitmask. The CoglBitmask is intended to be cheap if less than 32 bits are used. If more bits are required it will allocate a GArray. The type is meant to be allocated on the stack but because it can require additional resources it also has a destroy function. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-20 16:31:42 +00:00
$(srcdir)/cogl-bitmask.h \
$(srcdir)/cogl-bitmask.c \
cogl-shader: unifies the driver/{gl,gles} shader files The per driver implementations of cogl-shader.c had become almost identical we now have a single cogl/cogl-shader.c instead.
2010-08-02 20:40:55 +00:00
$(srcdir)/cogl-shader-private.h \
$(srcdir)/cogl-shader.c \
matrix gtype: registers a boxed type for CoglMatrix To allow us to have gobject properties that accept a CoglMatrix value we need to register a GType. This adds a cogl_gtype_matrix_get_type function that will register a static boxed type called "CoglMatrix". This adds a new section to the reference manual for GType integration functions.
2010-11-29 21:42:06 +00:00
$(srcdir)/cogl-gtype-private.h \
Add temporary cogl-clutter.h to aid splitting out Cogl This gives us a way to clearly track the internal Cogl API that Clutter depends on. The aim is to split Cogl out from Clutter into a standalone 3D graphics API and eventually we want to get rid of any private interfaces for Clutter so its useful to have a handle on that task. Actually it's not as bad as I was expecting though.
2011-02-22 18:25:29 +00:00
$(srcdir)/cogl-point-in-poly-private.h \
$(srcdir)/cogl-point-in-poly.c \
$(srcdir)/cogl-clutter.c \
Add the code from FreeBSD for their linked-list/queue implementation This directly copies in the header from the FreeBSD kernel for their linked-list implementation. A later patch will modify it but this patch is here so we can have a clear patch to show what the changes are. Using the list implementation from this header is beneficial as opposed to using GList because it's possible to embed the list pointers directly into another struct. This saves a separate allocation and it also makes it possible to remove an item from the list without having to iterate the entire list to find its list node. The header provides four different list types: single and doubley linked lists and each of them can either have a header with pointers to the beginning and end or just to the beginning. Glib effectively only provides single and doubley linked lists with a pointer to the beginning or a doubley-linked list with a pointer to both (GQueue). https://bugzilla.gnome.org/show_bug.cgi?id=652514
2011-06-13 15:11:31 +00:00
$(srcdir)/cogl-queue.h \
Re-organize the source layout As part of an effort towards being able to write non-opengl based backends for Cogl this moves most of the opengl specific code under drivers/gl. drivers/gl and drivers/gles have been moved to drivers/gl/gl and drivers/gl/es respectively. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 7dc482facb0a265c7f48660079e7e12dd7a2813e)
2012-09-12 20:25:11 +00:00
$(srcdir)/winsys/cogl-winsys-stub-private.h \
Make stub winsys into a proper winsys backend Instead of the stub winsys being a special case set of #ifdef'd code used when COGL_HAS_FULL_WINSYS wasn't defined, the stub winsys now implements a CoglWinsysVtable like all other winsys backends (it's just that everything is a NOP). This way we can get rid of the COGL_HAS_FULL_WINSYS define and also the stub winsys can be runtime selected whereas before it was incompatible with all other winsys backends.
2011-05-17 14:00:38 +00:00
$(srcdir)/winsys/cogl-winsys-stub.c \
cogl: Add support for reading a cogl.conf config file When cogl initializes we now check for a cogl/cogl.conf in any of the system config dirs (determined using $XDG_CONFIG_DIRS on linux) we then also check the user's config directory (determined using XDG_CONFIG_HOME on linux) for a cogl/cogl.conf file. Options specified in the user config file have priority over the system config options. The config file has an .ini style syntax with a mandatory [global] section and we currently understand 3 keynames: COGL_DEBUG, COGL_DRIVER and COGL_RENDERER which have the same semantics as the corresponding environment variables. Options set using the environment variables have priority over options set in the config files. To allow users to undo the enabling of debug options in config files this patch also adds a check for COGL_NO_DEBUG environment variable which will disable the specified options which may have been enabled in config files. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-03 17:15:54 +00:00
$(srcdir)/cogl-config-private.h \
$(srcdir)/cogl-config.c \
cogl-program: Move the code for CoglBoxedValue to its own file The code for manipulating CoglBoxedValues is now separated from cogl-program.c into its own file. That way when we add support for setting uniform values on a CoglPipeline the code for storing the values can be shared. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-27 15:54:50 +00:00
$(srcdir)/cogl-boxed-value.h \
$(srcdir)/cogl-boxed-value.c \
Add a CoglSnippet type This adds a CoglObject called CoglSnippet which will be used to store strings used as GLSL snippets to be attached at hook points to a CoglPipeline. The snippets can currently contain three strings: declarations - This will be placed in the global scope and is intended to be used to declare uniforms, attributes and functions. pre - This will be inserted before the hook point. post - This will be inserted after the hook point. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-17 16:38:49 +00:00
$(srcdir)/cogl-snippet-private.h \
$(srcdir)/cogl-snippet.c \
Add support for main loop integration This adds two new functions: void cogl_poll_get_info (CoglContext *context, CoglPollFD **poll_fds, int *n_poll_fds, gint64 *timeout); void cogl_poll_dispatch (CoglContext *context, const CoglPollFD *poll_fds, int n_poll_fds); The application is expected to call the first function whenever it is about to block to go idle, and the second function whenever it comes out of idle. This gives Cogl winsys's the ability poll file descriptors for events. For example when handing swap complete notifications, it can report that it needs to block on a file descriptor. The two functions are backed by winsys virtual functions. There are currently no implementations. The default handler for get_info just reports no file descriptors and an infinite timeout. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-16 17:49:28 +00:00
$(srcdir)/cogl-poll.c \
gl-prototypes: split up cogl-ext-functions.h This splits up cogl-ext-functions.h in to sets of prototypes that can be included separately so that we can include just core gles1 or gles2 functions without any extensions. Since eglGetProcAddress can not be used to query core client APIs and some implementations (notably on Android) can return a garbage pointer instead of NULL this will allow us to explicitly check when to use eglGetProcAddress and when to use dlsym(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-01 21:45:07 +00:00
$(srcdir)/gl-prototypes/cogl-all-functions.h \
$(srcdir)/gl-prototypes/cogl-gles1-functions.h \
$(srcdir)/gl-prototypes/cogl-gles2-functions.h \
$(srcdir)/gl-prototypes/cogl-core-functions.h \
$(srcdir)/gl-prototypes/cogl-in-gles-core-functions.h \
$(srcdir)/gl-prototypes/cogl-in-gles1-core-functions.h \
$(srcdir)/gl-prototypes/cogl-in-gles2-core-functions.h \
$(srcdir)/gl-prototypes/cogl-fixed-functions.h \
$(srcdir)/gl-prototypes/cogl-glsl-functions.h \
Adds internal CoglMemoryStack utility API This adds a very minimal internal allocator api that lets us create a dynamically growable (grow only) stack. Underlying the allocator is the idea of "sub stacks" which are simply malloc()'d chunks of memory kept in a linked list. The stack itself maintains a pointer to the current sub-stack and a current sub-stack-offset. 99% of the time allocating from the stack is just a case of returning a pointer to the current sub-stack + sub-stack-offset and bumping the offset by the allocation size. If there isn't room in the current sub-stack then we walk through the list of free sub-stacks looking for one that's big enough for the allocation and if we reach the end of the list then we allocate a new sub-stack twice as big as the last (or twice as big as the requested allocation if that's bigger). Since it's a stack model there is no api to free allocations, just a function to rewind the stack to the beginning. We expect this to be useful in multiple places in Cogl as an extremely fast allocator in cases when we know we can scrap all the allocations after we're done figuring something out or as a building block for other allocators. For example the tessellator used for CoglPath allocates lots of tiny structures that can all be freed after tessellation. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ee4a7a1b7f695bdfeb10ffa4112e776beea0a9d)
2011-09-04 12:40:18 +00:00
$(srcdir)/cogl-memory-stack-private.h \
$(srcdir)/cogl-memory-stack.c \
Adds a "magazine" allocator for chunks of fixed size This adds a very minimal and fast allocator for chunks of memory of a predetermined size. This has some similarities to the glib slice allocator although notably it is not thread safe and instead of internally tracking multiple magazines for various sized allocations the api lets you explicitly allocate a single magazine for a single specific size and a pointer to the magazine is passed explicitly to the allocate and free functions. This allocator builds on the CoglMemoryStack allocator as an underlying heap allocator and just never rewinds the stack. This means the heap is effectively a grow only linked list of malloc()'d blocks of memory. A CoglMagazine tracks a singly linked list of chunks of a predetermined size and _cogl_magazine_chunk_alloc() simply unlinks and returns the head of the list. If the list is empty it falls back to allocating from the underlying stack. _cogl_magazine_chunk_free() links the chunk back into the singly linked list for re-use. The chunk size passed to _cogl_magazine_new() is automatically rounded to a multiple of 8 bytes to ensure that all stack allocations end up aligned to 8 bytes. This also ensures that when a chunk is freed then it will be large enough to store a pointer to the next free chunk as part of a singly linked list. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 17799c2f109a008d6cf767f501b81aa9b32bbda8)
2012-03-23 12:18:45 +00:00
$(srcdir)/cogl-magazine-private.h \
$(srcdir)/cogl-magazine.c \
build: add newly introduced header to fix make dist Missing bit of 4bb6eff3dbd50d8fef7d6bdbed55c5aaa70036a8 Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 1674cf28f1f5b71bd25a1f253c99825d427dd243)
2012-05-22 13:17:11 +00:00
$(srcdir)/cogl-gles2-context-private.h \
Adds initial GLES2 integration support This makes it possible to integrate existing GLES2 code with applications using Cogl as the rendering api. Currently all GLES2 usage is handled with separate GLES2 contexts to ensure that GLES2 api usage doesn't interfere with Cogl's own use of OpenGL[ES]. The api has been designed though so we can provide tighter integration later. The api would allow us to support GLES2 virtualized on top of an OpenGL/GLX driver as well as GLES2 virtualized on the core rendering api of Cogl itself. Virtualizing the GLES2 support on Cogl will allow us to take advantage of Cogl debugging facilities as well as let us optimize the cost of allocating multiple GLES2 contexts and switching between them which can both be very expensive with many drivers. As as a side effect of this patch Cogl can also now be used as a portable window system binding API for GLES2 as an alternative to EGL. Parts of this patch are based on work done by Tomeu Vizoso <tomeu.vizoso@collabora.com> who did the first iteration of adding GLES2 API support to Cogl so that WebGL support could be added to webkit-clutter. This patch adds a very minimal cogl-gles2-context example that shows how to create a gles2 context, clear the screen to a random color and also draw a triangle with the cogl api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 4bb6eff3dbd50d8fef7d6bdbed55c5aaa70036a8)
2012-03-06 03:21:30 +00:00
$(srcdir)/cogl-gles2-context.c \
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
$(srcdir)/cogl-error-private.h \
$(srcdir)/cogl-error.c \
Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-28 01:02:02 +00:00
$(NULL)
Add a utility to make a GSource out of a CoglContext The GSource is created using cogl_glib_source_new which takes a pointer to a CoglContext. The source calls cogl_poll_get_info() in its prepare function and cogl_poll_dispatch() in its dispatch function. The poll FDs on the source are updated according to what Cogl reports. The header is only included and the source only compiled if Cogl is configured with GLib support. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 14:38:28 +00:00
if USE_GLIB
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
cogl_experimental_h += \
Add a utility to make a GSource out of a CoglContext The GSource is created using cogl_glib_source_new which takes a pointer to a CoglContext. The source calls cogl_poll_get_info() in its prepare function and cogl_poll_dispatch() in its dispatch function. The poll FDs on the source are updated according to what Cogl reports. The header is only included and the source only compiled if Cogl is configured with GLib support. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 14:38:28 +00:00
$(srcdir)/cogl-glib-source.h
cogl_sources_c += \
$(srcdir)/cogl-glib-source.c
endif
Pass all Xlib events through Cogl The Clutter X11 backend now passes all events through _cogl_xlib_handle_event. This function can now internally be hooked with _cogl_xlib_add_filter. These are added to a list of callbacks which are all called in turn by _cogl_xlib_handle_event. This is intended to be used internally in Cogl by any parts that need to see Xlib events. Cogl now also has an internally exposed function to set a pointer to the Xlib display. This is stored in a global variable. The Clutter X11 backend sets this. _cogl_xlib_handle_event and _cogl_xlib_set_display can be removed once Cogl gains a proper window system abstraction.
2010-05-19 15:13:07 +00:00
if SUPPORT_XLIB
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
cogl_1_public_h += \
Remove inclusion of Xlib headers in Cogl headers Xlib headers define many trivially named objects which can later cause name collision problems when only cogl.h header is included in a program or library. Xlib headers are now only included through including the standalone header cogl-xlib.h. https://bugzilla.gnome.org/show_bug.cgi?id=661174 Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-17 16:55:35 +00:00
$(srcdir)/cogl-clutter-xlib.h \
work towards consistent platform file/symbol naming we've got into a bit of a mess with how we name platform specific symbols and files, so this is a first pass at trying to tidy that up. All platform specific symbols should be named like cogl_<platform>_symbol_name and similarly files should be named like cogl-<platform>-filename.c This patch tackles the X11 specific renderer/display APIs as a start. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-28 13:16:24 +00:00
$(srcdir)/cogl-xlib-renderer.h
path 2.0: update path API for experimental 2.0 API When COGL_ENABLE_EXPERIMENTAL_2_0_API is defined cogl.h will now include cogl2-path.h which changes cogl_path_new() so it can directly return a CoglPath pointer; it no longer exposes a prototype for cogl_{get,set}_path and all the remaining cogl_path_ functions now take an explicit path as their first argument. The idea is that we want to encourage developers to retain path objects for as long as possible so they can take advantage of us uploading the path geometry to the GPU. Currently although it is possible to start a new path and query the current path, it is not convenient. The other thing is that we want to get Cogl to the point where nothing depends on a global, current context variable. This will allow us to one day define a sensible threading model if/when that is ever desired.
2010-11-04 00:27:47 +00:00
cogl_experimental_h += \
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 12:28:33 +00:00
$(srcdir)/winsys/cogl-texture-pixmap-x11.h \
$(srcdir)/cogl-xlib.h
Add a CoglTexturePixmapX11 texture backend This is a publicly exposed texture backend to create a texture which contains the contents of an X11 pixmap. The API is currently marked as experimental. The backend internally holds a handle to another texture. All of the backend virtuals simply redirect to the internal texture. The texture can optionally be automatically updated if the automatic_updates parameter is TRUE. If set then Cogl will listen for damage events on the pixmap and update the texture accordingly. Alternatively a damage object can be created externally and passed down to Cogl. The updates can be performed with XGetImage, XShmGetImage or the GLX_EXT_texture_pixmap extension. If the TFP extension is used it will optionally try to create a rectangle texture if the driver does not support NPOTs or it is forced through the COGL_PIXMAP_TEXTURE_RECTANGLE or CLUTTER_PIXMAP_TEXTURE_RECTANGLE environment variables. If the GLXFBConfig does not support mipmapping then it will fallback to using X{Shm,}GetImage. It keeps a separate texture around for this so that it can later start using the TFP texture again if the texture is later drawn with mipmaps disabled.
2010-05-25 17:56:14 +00:00
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
cogl_sources_c += \
work towards consistent platform file/symbol naming we've got into a bit of a mess with how we name platform specific symbols and files, so this is a first pass at trying to tidy that up. All platform specific symbols should be named like cogl_<platform>_symbol_name and similarly files should be named like cogl-<platform>-filename.c This patch tackles the X11 specific renderer/display APIs as a start. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-28 13:16:24 +00:00
$(srcdir)/cogl-x11-renderer-private.h \
$(srcdir)/cogl-xlib-renderer-private.h \
$(srcdir)/cogl-xlib-renderer.c \
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 12:28:33 +00:00
$(srcdir)/cogl-xlib.c \
build: Fix make distcheck Some header files were split but never included in the list of source files and thus not distributed.
2011-05-06 16:10:42 +00:00
$(srcdir)/cogl-xlib-private.h \
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 12:28:33 +00:00
$(srcdir)/winsys/cogl-texture-pixmap-x11.c \
$(srcdir)/winsys/cogl-texture-pixmap-x11-private.h
build: expose automake conditionals for cogl winsys Expose the ./configured window system/backend options to the Cogl automake files via some new SUPPORT_XYZ conditionals.
2009-10-08 11:08:21 +00:00
endif
Pass all Xlib events through Cogl The Clutter X11 backend now passes all events through _cogl_xlib_handle_event. This function can now internally be hooked with _cogl_xlib_add_filter. These are added to a list of callbacks which are all called in turn by _cogl_xlib_handle_event. This is intended to be used internally in Cogl by any parts that need to see Xlib events. Cogl now also has an internally exposed function to set a pointer to the Xlib display. This is stored in a global variable. The Clutter X11 backend sets this. _cogl_xlib_handle_event and _cogl_xlib_set_display can be removed once Cogl gains a proper window system abstraction.
2010-05-19 15:13:07 +00:00
if SUPPORT_GLX
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
cogl_sources_c += \
work towards consistent platform file/symbol naming we've got into a bit of a mess with how we name platform specific symbols and files, so this is a first pass at trying to tidy that up. All platform specific symbols should be named like cogl_<platform>_symbol_name and similarly files should be named like cogl-<platform>-filename.c This patch tackles the X11 specific renderer/display APIs as a start. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-28 13:16:24 +00:00
$(srcdir)/cogl-glx-renderer-private.h \
$(srcdir)/cogl-glx-display-private.h \
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 12:28:33 +00:00
$(srcdir)/winsys/cogl-winsys-glx-feature-functions.h \
Add -Wmissing-declarations to maintainer flags and fix problems This option to GCC makes it give a warning whenever a global function is defined without a declaration. This should catch cases were we've defined a function but forgot to put it in a header. In that case it is either only used within one file so we should make it static or we should declare it in a header. The following changes where made to fix problems: • Some functions were made static • cogl-path.h (the one containing the 1.0 API) was split into two files, one defining the functions and one defining the enums so that cogl-path.c can include the enum and function declarations from the 2.0 API as well as the function declarations from the 1.0 API. • cogl2-clip-state has been removed. This only had one experimental function called cogl_clip_push_from_path but as this is unstable we might as well remove it favour of the equivalent cogl_framebuffer_* API. • The GLX, SDL and WGL winsys's now have a private header to define their get_vtable function instead of directly declaring in the C file where it is called. • All places that were calling COGL_OBJECT_DEFINE need to have the cogl_is_whatever function declared so these have been added either as a public function or in a private header. • Some files that were not including the header containing their function declarations have been fixed to do so. • Any unused error quark functions have been removed. If we later want them we should add them back one by one and add a declaration for them in a header. • _cogl_is_framebuffer has been renamed to cogl_is_framebuffer and made a public function with a declaration in cogl-framebuffer.h • Similarly for CoglOnscreen. • cogl_vdraw_indexed_attributes is called cogl_framebuffer_vdraw_indexed_attributes in the header. The definition has been changed to match the header. • cogl_index_buffer_allocate has been removed. This had no declaration and I'm not sure what it's supposed to do. • CoglJournal has been changed to use the internal CoglObject macro so that it won't define an exported cogl_is_journal symbol. • The _cogl_blah_pointer_from_handle functions have been removed. CoglHandle isn't used much anymore anyway and in the few places where it is used I think it's safe to just use the implicit cast from void* to the right type. • The test-utils.h header for the conformance tests explicitly disables the -Wmissing-declaration option using a pragma because all of the tests declare their main function without a header. Any mistakes relating to missing declarations aren't really important for the tests. • cogl_quaternion_init_from_quaternion and init_from_matrix have been given declarations in cogl-quaternion.h Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-06 18:21:28 +00:00
$(srcdir)/winsys/cogl-winsys-glx-private.h \
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 12:28:33 +00:00
$(srcdir)/winsys/cogl-winsys-glx.c
Pass all Xlib events through Cogl The Clutter X11 backend now passes all events through _cogl_xlib_handle_event. This function can now internally be hooked with _cogl_xlib_add_filter. These are added to a list of callbacks which are all called in turn by _cogl_xlib_handle_event. This is intended to be used internally in Cogl by any parts that need to see Xlib events. Cogl now also has an internally exposed function to set a pointer to the Xlib display. This is stored in a global variable. The Clutter X11 backend sets this. _cogl_xlib_handle_event and _cogl_xlib_set_display can be removed once Cogl gains a proper window system abstraction.
2010-05-19 15:13:07 +00:00
endif
Add a WGL winsys This adds a full winsys to handle WGL and Win32.
2011-05-09 16:48:50 +00:00
if SUPPORT_WGL
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
cogl_experimental_h += \
renderer: split win32 api out into separate header This adds a cogl-win32-renderer.h for the win32 specific cogl-renderer API instead of having #ifdef guards in cogl-renderer.h Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-28 15:06:45 +00:00
$(srcdir)/cogl-win32-renderer.h
Add a WGL winsys This adds a full winsys to handle WGL and Win32.
2011-05-09 16:48:50 +00:00
cogl_sources_c += \
replace public native_event APIs with typesafe APIs This adds Xlib and Win32 typesafe replacements for cogl_renderer_handle_native_event, cogl_renderer_add_native_filter, cogl_renderer_remove_native_filter. The old functions are kept as an implementation detail so we can share code. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-28 12:38:50 +00:00
$(srcdir)/cogl-win32-renderer.c \
Add -Wmissing-declarations to maintainer flags and fix problems This option to GCC makes it give a warning whenever a global function is defined without a declaration. This should catch cases were we've defined a function but forgot to put it in a header. In that case it is either only used within one file so we should make it static or we should declare it in a header. The following changes where made to fix problems: • Some functions were made static • cogl-path.h (the one containing the 1.0 API) was split into two files, one defining the functions and one defining the enums so that cogl-path.c can include the enum and function declarations from the 2.0 API as well as the function declarations from the 1.0 API. • cogl2-clip-state has been removed. This only had one experimental function called cogl_clip_push_from_path but as this is unstable we might as well remove it favour of the equivalent cogl_framebuffer_* API. • The GLX, SDL and WGL winsys's now have a private header to define their get_vtable function instead of directly declaring in the C file where it is called. • All places that were calling COGL_OBJECT_DEFINE need to have the cogl_is_whatever function declared so these have been added either as a public function or in a private header. • Some files that were not including the header containing their function declarations have been fixed to do so. • Any unused error quark functions have been removed. If we later want them we should add them back one by one and add a declaration for them in a header. • _cogl_is_framebuffer has been renamed to cogl_is_framebuffer and made a public function with a declaration in cogl-framebuffer.h • Similarly for CoglOnscreen. • cogl_vdraw_indexed_attributes is called cogl_framebuffer_vdraw_indexed_attributes in the header. The definition has been changed to match the header. • cogl_index_buffer_allocate has been removed. This had no declaration and I'm not sure what it's supposed to do. • CoglJournal has been changed to use the internal CoglObject macro so that it won't define an exported cogl_is_journal symbol. • The _cogl_blah_pointer_from_handle functions have been removed. CoglHandle isn't used much anymore anyway and in the few places where it is used I think it's safe to just use the implicit cast from void* to the right type. • The test-utils.h header for the conformance tests explicitly disables the -Wmissing-declaration option using a pragma because all of the tests declare their main function without a header. Any mistakes relating to missing declarations aren't really important for the tests. • cogl_quaternion_init_from_quaternion and init_from_matrix have been given declarations in cogl-quaternion.h Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-06 18:21:28 +00:00
$(srcdir)/winsys/cogl-winsys-wgl-private.h \
Add a WGL winsys This adds a full winsys to handle WGL and Win32.
2011-05-09 16:48:50 +00:00
$(srcdir)/winsys/cogl-winsys-wgl.c \
$(srcdir)/winsys/cogl-winsys-wgl-feature-functions.h
endif
Create standalone public wayland client/server headers Because the wayland-client-protocol.h header defines symbols that collide with the wayland-server-protocol.h header we allow applications to explicitly ensure that they are only including one at a time by exposing corresponding <cogl/cogl-wayland-client.h> and <cogl/cogl-wayland-server.h> headers. This also adds a missing guard to cogl-texture-2d.h that it isn't included directly. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-03-20 13:21:18 +00:00
if SUPPORT_WAYLAND_EGL_SERVER
cogl_experimental_h += \
$(srcdir)/cogl-wayland-server.h
endif
Adds wayland support to the cogl EGL winsys Wayland now supports integration via standard eglSurfaces which makes it possible to share more code with other EGL platforms. (though at some point cogl-winsys-egl.c really needs to gain a more formal CoglEGLPlatform abstraction so we can rein back on the amount of #ifdefs we have.)
2011-03-17 19:31:34 +00:00
if SUPPORT_EGL_PLATFORM_WAYLAND
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
cogl_experimental_h += \
Create standalone public wayland client/server headers Because the wayland-client-protocol.h header defines symbols that collide with the wayland-server-protocol.h header we allow applications to explicitly ensure that they are only including one at a time by exposing corresponding <cogl/cogl-wayland-client.h> and <cogl/cogl-wayland-server.h> headers. This also adds a missing guard to cogl-texture-2d.h that it isn't included directly. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-03-20 13:21:18 +00:00
$(srcdir)/cogl-wayland-renderer.h \
$(srcdir)/cogl-wayland-client.h
Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 17:24:40 +00:00
cogl_sources_c += \
$(srcdir)/winsys/cogl-winsys-egl-wayland.c \
$(srcdir)/winsys/cogl-winsys-egl-wayland-private.h
Adds wayland support to the cogl EGL winsys Wayland now supports integration via standard eglSurfaces which makes it possible to share more code with other EGL platforms. (though at some point cogl-winsys-egl.c really needs to gain a more formal CoglEGLPlatform abstraction so we can rein back on the amount of #ifdefs we have.)
2011-03-17 19:31:34 +00:00
endif
kms: Add first version of "baremetal" backend for EGL on KMS To start with this backend only supports creating a single CoglOnscreen framebuffer and will automatically set is up to display fullscreen on the first suitable crtc it can find. To compile this backend - get some dribbly black candles, sacrifice a goat and configure with: --enable-kms-egl-platform Note: There is currently a problem with using GLES2 with this winsys so you need to run with EGL_DRIVER=gl Note: If you have problems with mesa crashing in XCB during eglInitialize then you may need to explicitly run with EGL_PLATFORM=gbm Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-07 17:16:13 +00:00
if SUPPORT_EGL_PLATFORM_KMS
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
cogl_experimental_h += \
kms: defer setting crtc modes until first swap buffers Instead of creating a dummy framebuffer allocation just so we can setup crtc modes during display_setup we now wait until the first swap_buffers request before setting up the crtc modes. This patch also adds a cogl_kms_display_queue_modes_reset() function that allows developers to explicitly queue a reset of the crtc modes. The idea is that applications that handle VT switching can use this for VT enter events to explicitly ensure their mode is restored since modes are often not automatically restored correctly. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-30 11:06:41 +00:00
$(srcdir)/cogl-kms-renderer.h \
$(srcdir)/cogl-kms-display.h
kms: Add first version of "baremetal" backend for EGL on KMS To start with this backend only supports creating a single CoglOnscreen framebuffer and will automatically set is up to display fullscreen on the first suitable crtc it can find. To compile this backend - get some dribbly black candles, sacrifice a goat and configure with: --enable-kms-egl-platform Note: There is currently a problem with using GLES2 with this winsys so you need to run with EGL_DRIVER=gl Note: If you have problems with mesa crashing in XCB during eglInitialize then you may need to explicitly run with EGL_PLATFORM=gbm Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-07 17:16:13 +00:00
cogl_sources_c += \
Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 17:24:40 +00:00
$(srcdir)/winsys/cogl-winsys-egl-kms.c \
$(srcdir)/winsys/cogl-winsys-egl-kms-private.h
endif
Rename the EGL_X11 winsys to EGL_XLIB Eventually we might want to have an XCB-based EGL winsys. We already have xlib-specific API in CoglRenderer (eg, to set a foreign display) so the application needs to be able to specifically select between XCB and XLIB. This also removes the POWERVR part while renaming COGL_HAS_EGL_PLATFORM_POWERVR_X11_SUPPORT to COGL_HAS_EGL_PLATFORM_XLIB_SUPPORT because the winsys is equally applicable to Mesa. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-13 16:23:25 +00:00
if SUPPORT_EGL_PLATFORM_XLIB
Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 17:24:40 +00:00
cogl_sources_c += \
$(srcdir)/winsys/cogl-winsys-egl-x11.c \
$(srcdir)/winsys/cogl-winsys-egl-x11-private.h
endif
if SUPPORT_EGL_PLATFORM_POWERVR_NULL
cogl_sources_c += \
$(srcdir)/winsys/cogl-winsys-egl-null.c \
$(srcdir)/winsys/cogl-winsys-egl-null-private.h
endif
if SUPPORT_EGL_PLATFORM_GDL
cogl_sources_c += \
$(srcdir)/winsys/cogl-winsys-egl-gdl.c \
$(srcdir)/winsys/cogl-winsys-egl-gdl-private.h
endif
if SUPPORT_EGL_PLATFORM_ANDROID
cogl_sources_c += \
$(srcdir)/winsys/cogl-winsys-egl-android.c \
$(srcdir)/winsys/cogl-winsys-egl-android-private.h
kms: Add first version of "baremetal" backend for EGL on KMS To start with this backend only supports creating a single CoglOnscreen framebuffer and will automatically set is up to display fullscreen on the first suitable crtc it can find. To compile this backend - get some dribbly black candles, sacrifice a goat and configure with: --enable-kms-egl-platform Note: There is currently a problem with using GLES2 with this winsys so you need to run with EGL_DRIVER=gl Note: If you have problems with mesa crashing in XCB during eglInitialize then you may need to explicitly run with EGL_PLATFORM=gbm Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-07 17:16:13 +00:00
endif
dist: Make sure to dist cogl-winsys-egl-feature-functions.h cogl-winsys-egl-feature-functions.h wasn't being listed as source and so it wasn't ending up in dist tarballs. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-07-11 14:21:06 +00:00
if SUPPORT_EGL
Avoid including the EGL headers from the public Cogl headers Otherwise, X11 identifiers may leak and cause havoc in big applications Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit ed0cdca0eca815543619fe72fbd42d662d53f92d)
2012-07-10 13:14:07 +00:00
cogl_experimental_h += \
$(srcdir)/cogl-egl.h
cogl_nodist_experimental_h += \
$(builddir)/cogl-egl-defines.h
android: Add support for an EGL/Android winsys The native window type of the EGL/Android winsys is ANativeWinow*. The Android NDK gives you a pointer to this ANativeWindow and you just need to configure that window using the EGLConfig you are choosing when creating the context. This means you have to know the ANativeWindow* window before creating the context. This is solved here by just having a global variable you can set with cogl_android_set_native_window() before creating the context. This is a bit ugly though, and it conceptually belongs to the OnScreen creation to know which ANativeWindow* to use. This would need a "lazy context creation" mechanism, waiting for the user to create the OnScreen to initialize the GL context.
2011-05-16 15:43:30 +00:00
cogl_sources_c += \
Add _cogl_egl_texture_2d_new_from_image API This adds an internal texture_2d constructor that can wrap an EGLImage as a CoglTexture2D. The plan is to utilize this for texture-from-pixmap support with EGL as well as creating textures from wayland buffers.
2011-05-24 21:34:10 +00:00
$(srcdir)/winsys/cogl-winsys-egl.c \
dist: Make sure to dist cogl-winsys-egl-feature-functions.h cogl-winsys-egl-feature-functions.h wasn't being listed as source and so it wasn't ending up in dist tarballs. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-07-11 14:21:06 +00:00
$(srcdir)/winsys/cogl-winsys-egl-feature-functions.h \
Add _cogl_egl_texture_2d_new_from_image API This adds an internal texture_2d constructor that can wrap an EGLImage as a CoglTexture2D. The plan is to utilize this for texture-from-pixmap support with EGL as well as creating textures from wayland buffers.
2011-05-24 21:34:10 +00:00
$(srcdir)/winsys/cogl-winsys-egl-private.h
android: Add support for an EGL/Android winsys The native window type of the EGL/Android winsys is ANativeWinow*. The Android NDK gives you a pointer to this ANativeWindow and you just need to configure that window using the EGLConfig you are choosing when creating the context. This means you have to know the ANativeWindow* window before creating the context. This is solved here by just having a global variable you can set with cogl_android_set_native_window() before creating the context. This is a bit ugly though, and it conceptually belongs to the OnScreen creation to know which ANativeWindow* to use. This would need a "lazy context creation" mechanism, waiting for the user to create the OnScreen to initialize the GL context.
2011-05-16 15:43:30 +00:00
endif
Update the SDL winsys The SDL winsys was missing a few minor features, such as the implementation. This patch adds that in. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-14 12:09:53 +00:00
if SUPPORT_SDL
Rework sdl integration api This re-works the SDL integration api to simplify the integration for application developers and also allow Cogl to know when the application is about to go idle waiting for events so it can perform idle book-keeping work. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-04-06 10:16:19 +00:00
cogl_experimental_h += $(srcdir)/cogl-sdl.h
Update the SDL winsys The SDL winsys was missing a few minor features, such as the implementation. This patch adds that in. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-14 12:09:53 +00:00
cogl_sources_c += \
Add -Wmissing-declarations to maintainer flags and fix problems This option to GCC makes it give a warning whenever a global function is defined without a declaration. This should catch cases were we've defined a function but forgot to put it in a header. In that case it is either only used within one file so we should make it static or we should declare it in a header. The following changes where made to fix problems: • Some functions were made static • cogl-path.h (the one containing the 1.0 API) was split into two files, one defining the functions and one defining the enums so that cogl-path.c can include the enum and function declarations from the 2.0 API as well as the function declarations from the 1.0 API. • cogl2-clip-state has been removed. This only had one experimental function called cogl_clip_push_from_path but as this is unstable we might as well remove it favour of the equivalent cogl_framebuffer_* API. • The GLX, SDL and WGL winsys's now have a private header to define their get_vtable function instead of directly declaring in the C file where it is called. • All places that were calling COGL_OBJECT_DEFINE need to have the cogl_is_whatever function declared so these have been added either as a public function or in a private header. • Some files that were not including the header containing their function declarations have been fixed to do so. • Any unused error quark functions have been removed. If we later want them we should add them back one by one and add a declaration for them in a header. • _cogl_is_framebuffer has been renamed to cogl_is_framebuffer and made a public function with a declaration in cogl-framebuffer.h • Similarly for CoglOnscreen. • cogl_vdraw_indexed_attributes is called cogl_framebuffer_vdraw_indexed_attributes in the header. The definition has been changed to match the header. • cogl_index_buffer_allocate has been removed. This had no declaration and I'm not sure what it's supposed to do. • CoglJournal has been changed to use the internal CoglObject macro so that it won't define an exported cogl_is_journal symbol. • The _cogl_blah_pointer_from_handle functions have been removed. CoglHandle isn't used much anymore anyway and in the few places where it is used I think it's safe to just use the implicit cast from void* to the right type. • The test-utils.h header for the conformance tests explicitly disables the -Wmissing-declaration option using a pragma because all of the tests declare their main function without a header. Any mistakes relating to missing declarations aren't really important for the tests. • cogl_quaternion_init_from_quaternion and init_from_matrix have been given declarations in cogl-quaternion.h Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-06 18:21:28 +00:00
$(srcdir)/winsys/cogl-winsys-sdl-private.h \
Rework sdl integration api This re-works the SDL integration api to simplify the integration for application developers and also allow Cogl to know when the application is about to go idle waiting for events so it can perform idle book-keeping work. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-04-06 10:16:19 +00:00
$(srcdir)/winsys/cogl-winsys-sdl.c \
$(srcdir)/cogl-sdl.c
Update the SDL winsys The SDL winsys was missing a few minor features, such as the implementation. This patch adds that in. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-14 12:09:53 +00:00
endif
Add an SDL2 winsys This adds an alternate version of the SDL winsys using the SDL 2 API. The two versions are mutually exclusive and share the same CoglWinsysID. Version 2 of SDL fits a little bit better with Cogl because it supports multiple windows and the video subsystem can be initialised entirely independently of the rest of the subsystems. The SDL2 winsys creates an invisible dummy window in order to bind the GL context after creating the Cogl display. This is similar to how the X11 winsys's work. SDL2 seems to support compiling with support for both GL and GLES. However there doesn't seem to be a way to select between the two backends outside of SDL. In fact if you do compile them both in it seems to break down because it will always try to use the window system functions from the GLES backend because those are filled in second in the vtable. However when creating the window it will always prefer to use the GL function to choose a visual. This function gets confused because the GL backend has not been initialised at that point. The Cogl backend therefore just leaves it up to SDL to pick a sensible backend. It will then verify that it picked a GL library which matches the Cogl driver by checking the string from glGetString(GL_VERSION). Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 6cb5ab41355e7bfe28f367cf4afa39a7afcfeec2)
2012-06-14 13:42:16 +00:00
if SUPPORT_SDL2
cogl_experimental_h += $(srcdir)/cogl-sdl.h
cogl_sources_c += \
$(srcdir)/winsys/cogl-winsys-sdl-private.h \
$(srcdir)/winsys/cogl-winsys-sdl2.c \
$(srcdir)/cogl-sdl.c
endif
build: expose automake conditionals for cogl winsys Expose the ./configured window system/backend options to the Cogl automake files via some new SUPPORT_XYZ conditionals.
2009-10-08 11:08:21 +00:00
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
EXTRA_DIST += stb_image.c
Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-28 01:02:02 +00:00
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
# glib-mkenums rules
glib_enum_h = cogl-enum-types.h
glib_enum_c = cogl-enum-types.c
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
glib_enum_headers = $(cogl_1_public_h)
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
include $(top_srcdir)/build/autotools/Makefile.am.enums
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
lib_LTLIBRARIES += libcogl.la
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
cogl/Makefile.am: pass EXTRA_LDFLAGS for linking When building on windows for example we need to ensure we pass -no-undefined to the linker. Although we were substituting a COGL_EXTRA_LDFLAGS variable from our configure.ac we forgot to reference that when linking cogl.
2011-04-19 16:40:57 +00:00
libcogl_la_LIBADD = -lm $(COGL_DEP_LIBS) $(COGL_EXTRA_LDFLAGS)
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
if SUPPORT_GLX
libcogl_la_LIBADD += -ldl
endif
build: Allow to build cogl without an external glib dependency This commit pushes --disable-glib to the extreme of embedding the par of glib cogl depends on in tree to be able to generate a DSO that does not depend on an external glib. To do so, it: - keeps a lot of glib's configure.ac in as-glibconfig.m4 - pulls the code cogl depends on and the necessary dependencies Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-09-17 01:20:10 +00:00
if !USE_GLIB
libcogl_la_LIBADD += $(top_builddir)/deps/glib/libglib.la
libcogl_la_LIBADD += $(top_builddir)/deps/gmodule/libgmodule.la
endif
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
# XXX: The aim is to eventually get rid of all private API exports
consistently refer to cogl-pango as "cogl-pango" This renames the pango directory to cogl-pango and it renames the installed library to libcogl-pango instead of libcoglpango.
2011-05-05 21:04:07 +00:00
# for cogl-pango.
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
libcogl_la_LDFLAGS = \
-no-undefined \
-version-info @COGL_LT_CURRENT@:@COGL_LT_REVISION@:@COGL_LT_AGE@ \
-export-dynamic \
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 19:44:56 +00:00
-export-symbols-regex "^(cogl|_cogl_debug_flags|_cogl_atlas_new|_cogl_atlas_add_reorganize_callback|_cogl_atlas_reserve_space|_cogl_callback|_cogl_util_get_eye_planes_for_screen_poly|_cogl_atlas_texture_remove_reorganize_callback|_cogl_atlas_texture_add_reorganize_callback|_cogl_texture_foreach_sub_texture_in_region|_cogl_atlas_texture_new_with_size|_cogl_profile_trace_message|_cogl_context_get_default).*"
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
libcogl_la_SOURCES = $(cogl_sources_c)
nodist_libcogl_la_SOURCES = $(BUILT_SOURCES)
build: Start moving to a non-recursive layout *** WARNING: THIS COMMIT CHANGES THE BUILD *** Do not recurse into the backend directories to build private, internal libraries. We only recurse from clutter/ into the cogl sub-directory; from there, we don't recurse any further. All the backend-specific code in Cogl and Clutter is compiled conditionally depending on the macros defined by the configure script. We still recurse from the top-level directory into doc, clutter and tests, because gtk-doc and tests do not deal nicely with non-recursive layouts. This change makes Clutter compile slightly faster, and cleans up the build system, especially when dealing with introspection data. Ideally, we also want to make Cogl part of the top-level build, so that we can finally drop the sed trick to change the shared library from the GIR before compiling it. Currently disabled: ‣ OSX backend ‣ Fruity backend Currently enabled but untested: ‣ EGL backend ‣ Windows backend
2010-09-13 10:30:30 +00:00
path 2.0: update path API for experimental 2.0 API When COGL_ENABLE_EXPERIMENTAL_2_0_API is defined cogl.h will now include cogl2-path.h which changes cogl_path_new() so it can directly return a CoglPath pointer; it no longer exposes a prototype for cogl_{get,set}_path and all the remaining cogl_path_ functions now take an explicit path as their first argument. The idea is that we want to encourage developers to retain path objects for as long as possible so they can take advantage of us uploading the path geometry to the GPU. Currently although it is possible to start a new path and query the current path, it is not convenient. The other thing is that we want to get Cogl to the point where nothing depends on a global, current context variable. This will allow us to one day define a sensible threading model if/when that is ever desired.
2010-11-04 00:27:47 +00:00
# Cogl installed headers
Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-28 01:02:02 +00:00
cogl_headers = \
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
$(cogl_1_public_h) \
build: Make COGL pass distcheck Some changes to make COGL pass distcheck with Automake 1.11 and anal-retentiveness turned up to 11. The "major" change is the flattening of the winsys/ part of COGL, which is built directly inside libclutter-cogl.la instead of an intermediate libclutter-cogl-winsys.la object. Ideally, the whole COGL should be flattened out using a quasi-non-recursive Automake layout; unfortunately, the driver/ sub-section ships with identical targets and Automake cannot distinguish GL and GLES objects.
2009-10-23 11:15:25 +00:00
$(srcdir)/cogl-deprecated.h \
Don't include cogl-pango.h when scanning introspection data cogl/cogl-pango.h can't be included unless the include directory for Pango is given in the compiler flags. In an application, it is expected that if they are using this header then they would pull in cogl-pango-1.0.pc which would provide this. However when building Cogl itself we might be building without Pango support so the Makefile can't rely on PANGO_CFLAGS. This was breaking building the introspection data because cogl-pango.h was listed as one of the files to scan but it can't be included.
2011-05-16 14:41:25 +00:00
$(srcdir)/cogl-pango.h \
Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-28 01:02:02 +00:00
$(NULL)
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
coglincludedir = $(includedir)/cogl/cogl
coglinclude_HEADERS = $(cogl_headers) $(cogl_experimental_h)
Avoid including the EGL headers from the public Cogl headers Otherwise, X11 identifiers may leak and cause havoc in big applications Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit ed0cdca0eca815543619fe72fbd42d662d53f92d)
2012-07-10 13:14:07 +00:00
nodist_coglinclude_HEADERS = $(cogl_nodist_experimental_h) cogl-defines.h cogl-enum-types.h
Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-28 01:02:02 +00:00
cogl-gles2: Install headers in cogl/ instead of in cogl2/ Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-08-16 13:17:18 +00:00
cogl_proto_includedir = $(includedir)/cogl/cogl/gl-prototypes
Adds initial GLES2 integration support This makes it possible to integrate existing GLES2 code with applications using Cogl as the rendering api. Currently all GLES2 usage is handled with separate GLES2 contexts to ensure that GLES2 api usage doesn't interfere with Cogl's own use of OpenGL[ES]. The api has been designed though so we can provide tighter integration later. The api would allow us to support GLES2 virtualized on top of an OpenGL/GLX driver as well as GLES2 virtualized on the core rendering api of Cogl itself. Virtualizing the GLES2 support on Cogl will allow us to take advantage of Cogl debugging facilities as well as let us optimize the cost of allocating multiple GLES2 contexts and switching between them which can both be very expensive with many drivers. As as a side effect of this patch Cogl can also now be used as a portable window system binding API for GLES2 as an alternative to EGL. Parts of this patch are based on work done by Tomeu Vizoso <tomeu.vizoso@collabora.com> who did the first iteration of adding GLES2 API support to Cogl so that WebGL support could be added to webkit-clutter. This patch adds a very minimal cogl-gles2-context example that shows how to create a gles2 context, clear the screen to a random color and also draw a triangle with the cogl api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 4bb6eff3dbd50d8fef7d6bdbed55c5aaa70036a8)
2012-03-06 03:21:30 +00:00
cogl_proto_include_HEADERS = $(cogl_gl_prototypes_h)
cogl/Makefile.am: VS support-Create a .bat to gen enums Pre-generate a .bat file to be used to generate the cogl-enum-types.[ch] for the build process. This will greatly simplify the maintenace process as the listing of headers to be parsed by glib-mkenums can be manifested automatically during 'make dist', and this list changes quite a bit during the development cycle.
2011-12-08 08:16:58 +00:00
dist-hook: ../build/win32/vs9/cogl.vcproj ../build/win32/vs10/cogl.vcxproj ../build/win32/vs10/cogl.vcxproj.filters ../build/win32/gen-enums.bat
VS 2008/2010 project files to build Cogl These are the VS 2008/2010 project files to build Cogl, with a README.txt to explain the process involved. Note that the Cogl and Cogl-Pango projects (and filters for VS2010) are expanded with the correct source file listings during "make dist", which is done to simplify maintenance of these project files. -added preconfigured config.h(.win32.in), which is expanded with the correct versioining info during autogen -added preconfigued cogl/cogl-defines.h.win32 -added symbols files for cogl and cogl-pango -Have configure.ac expand the config.h.win32.in into config.h.win32 with the correct versioning info, etc, and to include the Visual C++ project files for distribution -Added rules in cogl/Makefile.am to expand the cogl VS 2008/2010 projects and filters from the templates with up-to-date source file listings, to distribute cogl-enum-types.c, cogl-enum-types.h to ease compilation and to avoid depending on PERL on Windows installations. -Added rules in cogl-pango/Makefile.am to expand the cogl-pango VS2008/ 2010 projects and filters from the templates with up-to-date source file listings. -Added/edited various Makefile.am's in build to distribute the VS2008/2010 project files and associated items required for the build. -Update .gitignore. There needs to be a pre-configured config.h(.win32) and its template, config.h.win32.in for Visual C++ builds https://bugzilla.gnome.org/show_bug.cgi?id=650020 Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-05-12 09:06:32 +00:00
# I know those filters below don't look nice, but this is to ensure the right files are in the Project files only *once*
../build/win32/vs9/cogl.vcproj: $(top_srcdir)/build/win32/vs9/cogl.vcprojin
for F in `echo $(cogl_sources_c) $(BUILT_SOURCES) | tr '/' '\\'`; do \
case $$F in \
cogl/Makefile.am: Fix filters for MSVC projects We need to filter out all the *-egl-* sources as well, as the original filter did not filter out the Wayland EGL sources (Sorry, I forgot to add the reviewed by line for the same patch in the cogl-1.10 branch :P) Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 3d4cb887a28d3bc2cde9e4e7cdd20a71c34a2eaa)
2012-03-30 08:45:34 +00:00
*-egl.c|*-egl-*.c|*-glx.c|*-xlib*.c|*-x11.c|*.wgl.c|*-gl.c|*-gles.c|*-kms.c|*-sdl.c|*.h) ;; \
VS 2008/2010 project files to build Cogl These are the VS 2008/2010 project files to build Cogl, with a README.txt to explain the process involved. Note that the Cogl and Cogl-Pango projects (and filters for VS2010) are expanded with the correct source file listings during "make dist", which is done to simplify maintenance of these project files. -added preconfigured config.h(.win32.in), which is expanded with the correct versioining info during autogen -added preconfigued cogl/cogl-defines.h.win32 -added symbols files for cogl and cogl-pango -Have configure.ac expand the config.h.win32.in into config.h.win32 with the correct versioning info, etc, and to include the Visual C++ project files for distribution -Added rules in cogl/Makefile.am to expand the cogl VS 2008/2010 projects and filters from the templates with up-to-date source file listings, to distribute cogl-enum-types.c, cogl-enum-types.h to ease compilation and to avoid depending on PERL on Windows installations. -Added rules in cogl-pango/Makefile.am to expand the cogl-pango VS2008/ 2010 projects and filters from the templates with up-to-date source file listings. -Added/edited various Makefile.am's in build to distribute the VS2008/2010 project files and associated items required for the build. -Update .gitignore. There needs to be a pre-configured config.h(.win32) and its template, config.h.win32.in for Visual C++ builds https://bugzilla.gnome.org/show_bug.cgi?id=650020 Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-05-12 09:06:32 +00:00
*.c) echo ' <File RelativePath="..\..\..\cogl\'$$F'" />' \
;; \
esac; \
done >cogl.sourcefiles
$(CPP) -P - <$(top_srcdir)/build/win32/vs9/cogl.vcprojin >$@
rm cogl.sourcefiles
../build/win32/vs10/cogl.vcxproj: $(top_srcdir)/build/win32/vs10/cogl.vcxprojin
for F in `echo $(cogl_sources_c) $(BUILT_SOURCES) | tr '/' '\\'`; do \
case $$F in \
cogl/Makefile.am: Fix filters for MSVC projects We need to filter out all the *-egl-* sources as well, as the original filter did not filter out the Wayland EGL sources (Sorry, I forgot to add the reviewed by line for the same patch in the cogl-1.10 branch :P) Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 3d4cb887a28d3bc2cde9e4e7cdd20a71c34a2eaa)
2012-03-30 08:45:34 +00:00
*-egl.c|*-egl-*.c|*-glx.c|*-xlib*.c|*-x11.c|*.wgl.c|*-gl.c|*-gles.c|*-kms.c|*-sdl.c|*.h) ;; \
VS 2008/2010 project files to build Cogl These are the VS 2008/2010 project files to build Cogl, with a README.txt to explain the process involved. Note that the Cogl and Cogl-Pango projects (and filters for VS2010) are expanded with the correct source file listings during "make dist", which is done to simplify maintenance of these project files. -added preconfigured config.h(.win32.in), which is expanded with the correct versioining info during autogen -added preconfigued cogl/cogl-defines.h.win32 -added symbols files for cogl and cogl-pango -Have configure.ac expand the config.h.win32.in into config.h.win32 with the correct versioning info, etc, and to include the Visual C++ project files for distribution -Added rules in cogl/Makefile.am to expand the cogl VS 2008/2010 projects and filters from the templates with up-to-date source file listings, to distribute cogl-enum-types.c, cogl-enum-types.h to ease compilation and to avoid depending on PERL on Windows installations. -Added rules in cogl-pango/Makefile.am to expand the cogl-pango VS2008/ 2010 projects and filters from the templates with up-to-date source file listings. -Added/edited various Makefile.am's in build to distribute the VS2008/2010 project files and associated items required for the build. -Update .gitignore. There needs to be a pre-configured config.h(.win32) and its template, config.h.win32.in for Visual C++ builds https://bugzilla.gnome.org/show_bug.cgi?id=650020 Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-05-12 09:06:32 +00:00
*.c) echo ' <ClCompile Include="..\..\..\cogl\'$$F'" />' \
;; \
esac; \
done >cogl.vs10.sourcefiles
$(CPP) -P - <$(top_srcdir)/build/win32/vs10/cogl.vcxprojin >$@
rm cogl.vs10.sourcefiles
../build/win32/vs10/cogl.vcxproj.filters: $(top_srcdir)/build/win32/vs10/cogl.vcxproj.filtersin
for F in `echo $(cogl_sources_c) $(BUILT_SOURCES) | tr '/' '\\'`; do \
case $$F in \
cogl/Makefile.am: Fix filters for MSVC projects We need to filter out all the *-egl-* sources as well, as the original filter did not filter out the Wayland EGL sources (Sorry, I forgot to add the reviewed by line for the same patch in the cogl-1.10 branch :P) Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 3d4cb887a28d3bc2cde9e4e7cdd20a71c34a2eaa)
2012-03-30 08:45:34 +00:00
*-egl.c|*-egl-*.c|*-glx.c|*-xlib*.c|*-x11.c|*.wgl.c|*-gl.c|*-gles.c|*-kms.c|*-sdl.c|*.h) ;; \
VS 2008/2010 project files to build Cogl These are the VS 2008/2010 project files to build Cogl, with a README.txt to explain the process involved. Note that the Cogl and Cogl-Pango projects (and filters for VS2010) are expanded with the correct source file listings during "make dist", which is done to simplify maintenance of these project files. -added preconfigured config.h(.win32.in), which is expanded with the correct versioining info during autogen -added preconfigued cogl/cogl-defines.h.win32 -added symbols files for cogl and cogl-pango -Have configure.ac expand the config.h.win32.in into config.h.win32 with the correct versioning info, etc, and to include the Visual C++ project files for distribution -Added rules in cogl/Makefile.am to expand the cogl VS 2008/2010 projects and filters from the templates with up-to-date source file listings, to distribute cogl-enum-types.c, cogl-enum-types.h to ease compilation and to avoid depending on PERL on Windows installations. -Added rules in cogl-pango/Makefile.am to expand the cogl-pango VS2008/ 2010 projects and filters from the templates with up-to-date source file listings. -Added/edited various Makefile.am's in build to distribute the VS2008/2010 project files and associated items required for the build. -Update .gitignore. There needs to be a pre-configured config.h(.win32) and its template, config.h.win32.in for Visual C++ builds https://bugzilla.gnome.org/show_bug.cgi?id=650020 Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-05-12 09:06:32 +00:00
*.c) echo ' <ClCompile Include="..\..\..\cogl\'$$F'"><Filter>Sources</Filter></ClCompile>' \
;; \
esac; \
done >cogl.vs10.sourcefiles.filters
$(CPP) -P - <$(top_srcdir)/build/win32/vs10/cogl.vcxproj.filtersin >$@
rm cogl.vs10.sourcefiles.filters
cogl/Makefile.am: VS support-Create a .bat to gen enums Pre-generate a .bat file to be used to generate the cogl-enum-types.[ch] for the build process. This will greatly simplify the maintenace process as the listing of headers to be parsed by glib-mkenums can be manifested automatically during 'make dist', and this list changes quite a bit during the development cycle.
2011-12-08 08:16:58 +00:00
cogl.vsenums_h:
cogl/Makefile.am: Correct the way gen-enums.bat is created Don't use --symbol-prefix cogl_gtype as we are still using the old namespace in cogl-1.12, so there will still be the various _get_type()'s like before Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-08-16 15:38:20 +00:00
echo 'perl %1\bin\glib-mkenums --template ../../cogl/cogl-enum-types.h.in ' >vsenums_h.temp1
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
for F in `echo $(cogl_1_public_h) $(srcdir)/cogl-win32-renderer.h`; do \
cogl/Makefile.am: VS support-Create a .bat to gen enums Pre-generate a .bat file to be used to generate the cogl-enum-types.[ch] for the build process. This will greatly simplify the maintenace process as the listing of headers to be parsed by glib-mkenums can be manifested automatically during 'make dist', and this list changes quite a bit during the development cycle.
2011-12-08 08:16:58 +00:00
case $$F in \
*xlib*.h|*wayland*.h) ;; \
*.h) echo '../../cogl'$$F' ' \
;; \
esac; \
done >>vsenums_h.temp1
cat vsenums_h.temp1 | sed 's_/cogl./_/cogl/_' >vsenums_h.temp
cat vsenums_h.temp | tr -d '\n' >>$@
echo '> ..\..\cogl\cogl-enum-types.h' >>$@
rm vsenums_h.temp1
rm vsenums_h.temp
cogl.vsenums_c:
cogl/Makefile.am: Correct the way gen-enums.bat is created Don't use --symbol-prefix cogl_gtype as we are still using the old namespace in cogl-1.12, so there will still be the various _get_type()'s like before Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-08-16 15:38:20 +00:00
echo 'perl %1\bin\glib-mkenums --template ../../cogl/cogl-enum-types.c.in ' >vsenums_c.temp1
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
for F in `echo $(cogl_1_public_h) $(srcdir)/cogl-win32-renderer.h`; do \
cogl/Makefile.am: VS support-Create a .bat to gen enums Pre-generate a .bat file to be used to generate the cogl-enum-types.[ch] for the build process. This will greatly simplify the maintenace process as the listing of headers to be parsed by glib-mkenums can be manifested automatically during 'make dist', and this list changes quite a bit during the development cycle.
2011-12-08 08:16:58 +00:00
case $$F in \
*xlib*.h|*wayland*.h) ;; \
*.h) echo '../../cogl'$$F' ' \
;; \
esac; \
done >>vsenums_c.temp1
cat vsenums_c.temp1 | sed 's_/cogl./_/cogl/_' >vsenums_c.temp
cat vsenums_c.temp | tr -d '\n' >>$@
echo '> ..\..\cogl\cogl-enum-types.c' >>$@
rm vsenums_c.temp1
rm vsenums_c.temp
../build/win32/gen-enums.bat: cogl.vsenums_h cogl.vsenums_c
echo 'if exist ..\..\cogl\cogl-enum-types.h goto DONE_COGL_ENUMS_H' >$@
cat cogl.vsenums_h >>$@
echo ':DONE_COGL_ENUMS_H' >>$@
echo 'if exist ..\..\cogl\cogl-enum-types.c goto DONE_COGL_ENUMS_C' >>$@
cat cogl.vsenums_c >>$@
echo ':DONE_COGL_ENUMS_C' >>$@
rm cogl.vsenums_h
rm cogl.vsenums_c
VS 2008/2010 project files to build Cogl These are the VS 2008/2010 project files to build Cogl, with a README.txt to explain the process involved. Note that the Cogl and Cogl-Pango projects (and filters for VS2010) are expanded with the correct source file listings during "make dist", which is done to simplify maintenance of these project files. -added preconfigured config.h(.win32.in), which is expanded with the correct versioining info during autogen -added preconfigued cogl/cogl-defines.h.win32 -added symbols files for cogl and cogl-pango -Have configure.ac expand the config.h.win32.in into config.h.win32 with the correct versioning info, etc, and to include the Visual C++ project files for distribution -Added rules in cogl/Makefile.am to expand the cogl VS 2008/2010 projects and filters from the templates with up-to-date source file listings, to distribute cogl-enum-types.c, cogl-enum-types.h to ease compilation and to avoid depending on PERL on Windows installations. -Added rules in cogl-pango/Makefile.am to expand the cogl-pango VS2008/ 2010 projects and filters from the templates with up-to-date source file listings. -Added/edited various Makefile.am's in build to distribute the VS2008/2010 project files and associated items required for the build. -Update .gitignore. There needs to be a pre-configured config.h(.win32) and its template, config.h.win32.in for Visual C++ builds https://bugzilla.gnome.org/show_bug.cgi?id=650020 Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-05-12 09:06:32 +00:00
EXTRA_DIST += \
Fix Visual C++ build -Create a pre-defined cogl/cogl-gl-header.h(.win32) that is to be used on any Windows builds, and adapt the MSVC build process to set up and use that file. -Fix up glib-mkenums code generation .bat file that is generated during "make"/"make dist", like the autotools-based builds. -Since cogl/cogl-defines.h now contain versionioning info, and it no longer directly includes the GL headers, update the pre-configured cogl-defines.h[.win32|.win32_SDL] and use autotools to fill in the versioning info during "make"/"make dist". -Fix up cogl/cogl-pango.rc.in so that they reflect the cogl-2.x versioning stuff correctly and versioning info can be filled in correctly during "make"/"make dist" Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 7ff42bb1c5280b0f53370f8d94ef5f10c9f39e2f)
2012-05-15 03:52:13 +00:00
cogl-defines.h.win32.in \
VS 2008/2010 project files to build Cogl These are the VS 2008/2010 project files to build Cogl, with a README.txt to explain the process involved. Note that the Cogl and Cogl-Pango projects (and filters for VS2010) are expanded with the correct source file listings during "make dist", which is done to simplify maintenance of these project files. -added preconfigured config.h(.win32.in), which is expanded with the correct versioining info during autogen -added preconfigued cogl/cogl-defines.h.win32 -added symbols files for cogl and cogl-pango -Have configure.ac expand the config.h.win32.in into config.h.win32 with the correct versioning info, etc, and to include the Visual C++ project files for distribution -Added rules in cogl/Makefile.am to expand the cogl VS 2008/2010 projects and filters from the templates with up-to-date source file listings, to distribute cogl-enum-types.c, cogl-enum-types.h to ease compilation and to avoid depending on PERL on Windows installations. -Added rules in cogl-pango/Makefile.am to expand the cogl-pango VS2008/ 2010 projects and filters from the templates with up-to-date source file listings. -Added/edited various Makefile.am's in build to distribute the VS2008/2010 project files and associated items required for the build. -Update .gitignore. There needs to be a pre-configured config.h(.win32) and its template, config.h.win32.in for Visual C++ builds https://bugzilla.gnome.org/show_bug.cgi?id=650020 Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-05-12 09:06:32 +00:00
cogl-defines.h.win32 \
Fix Visual C++ build -Create a pre-defined cogl/cogl-gl-header.h(.win32) that is to be used on any Windows builds, and adapt the MSVC build process to set up and use that file. -Fix up glib-mkenums code generation .bat file that is generated during "make"/"make dist", like the autotools-based builds. -Since cogl/cogl-defines.h now contain versionioning info, and it no longer directly includes the GL headers, update the pre-configured cogl-defines.h[.win32|.win32_SDL] and use autotools to fill in the versioning info during "make"/"make dist". -Fix up cogl/cogl-pango.rc.in so that they reflect the cogl-2.x versioning stuff correctly and versioning info can be filled in correctly during "make"/"make dist" Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 7ff42bb1c5280b0f53370f8d94ef5f10c9f39e2f)
2012-05-15 03:52:13 +00:00
cogl-defines.h.win32_SDL.in \
Bug 666349: Dist files needed by MSVC for SDL winsys Distribute the new VS2008/2010 project/solution files and the pre-configured cogl-defines.h(.win32_SDL) needed for the build with MSVC.
2011-12-16 09:18:31 +00:00
cogl-defines.h.win32_SDL \
Fix Visual C++ build -Create a pre-defined cogl/cogl-gl-header.h(.win32) that is to be used on any Windows builds, and adapt the MSVC build process to set up and use that file. -Fix up glib-mkenums code generation .bat file that is generated during "make"/"make dist", like the autotools-based builds. -Since cogl/cogl-defines.h now contain versionioning info, and it no longer directly includes the GL headers, update the pre-configured cogl-defines.h[.win32|.win32_SDL] and use autotools to fill in the versioning info during "make"/"make dist". -Fix up cogl/cogl-pango.rc.in so that they reflect the cogl-2.x versioning stuff correctly and versioning info can be filled in correctly during "make"/"make dist" Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 7ff42bb1c5280b0f53370f8d94ef5f10c9f39e2f)
2012-05-15 03:52:13 +00:00
cogl-gl-header.h.win32 \
Bug 664827: Autotools changes for Windows .rc files This will make autotools fill in the versioning info for the COGL/ COGL-Pango .rc files and distribute the resulting .rc files
2011-12-15 12:31:04 +00:00
cogl.symbols \
cogl.rc.in \
cogl.rc
VS 2008/2010 project files to build Cogl These are the VS 2008/2010 project files to build Cogl, with a README.txt to explain the process involved. Note that the Cogl and Cogl-Pango projects (and filters for VS2010) are expanded with the correct source file listings during "make dist", which is done to simplify maintenance of these project files. -added preconfigured config.h(.win32.in), which is expanded with the correct versioining info during autogen -added preconfigued cogl/cogl-defines.h.win32 -added symbols files for cogl and cogl-pango -Have configure.ac expand the config.h.win32.in into config.h.win32 with the correct versioning info, etc, and to include the Visual C++ project files for distribution -Added rules in cogl/Makefile.am to expand the cogl VS 2008/2010 projects and filters from the templates with up-to-date source file listings, to distribute cogl-enum-types.c, cogl-enum-types.h to ease compilation and to avoid depending on PERL on Windows installations. -Added rules in cogl-pango/Makefile.am to expand the cogl-pango VS2008/ 2010 projects and filters from the templates with up-to-date source file listings. -Added/edited various Makefile.am's in build to distribute the VS2008/2010 project files and associated items required for the build. -Update .gitignore. There needs to be a pre-configured config.h(.win32) and its template, config.h.win32.in for Visual C++ builds https://bugzilla.gnome.org/show_bug.cgi?id=650020 Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-05-12 09:06:32 +00:00
Bug 664827: Autotools changes for Windows .rc files This will make autotools fill in the versioning info for the COGL/ COGL-Pango .rc files and distribute the resulting .rc files
2011-12-15 12:31:04 +00:00
DISTCLEANFILES += ../build/win32/vs9/cogl.vcproj ../build/win32/vs10/cogl.vcxproj ../build/win32/vs10/cogl.vcxproj.filters ../build/win32/gen-enums.bat cogl.rc
VS 2008/2010 project files to build Cogl These are the VS 2008/2010 project files to build Cogl, with a README.txt to explain the process involved. Note that the Cogl and Cogl-Pango projects (and filters for VS2010) are expanded with the correct source file listings during "make dist", which is done to simplify maintenance of these project files. -added preconfigured config.h(.win32.in), which is expanded with the correct versioining info during autogen -added preconfigued cogl/cogl-defines.h.win32 -added symbols files for cogl and cogl-pango -Have configure.ac expand the config.h.win32.in into config.h.win32 with the correct versioning info, etc, and to include the Visual C++ project files for distribution -Added rules in cogl/Makefile.am to expand the cogl VS 2008/2010 projects and filters from the templates with up-to-date source file listings, to distribute cogl-enum-types.c, cogl-enum-types.h to ease compilation and to avoid depending on PERL on Windows installations. -Added rules in cogl-pango/Makefile.am to expand the cogl-pango VS2008/ 2010 projects and filters from the templates with up-to-date source file listings. -Added/edited various Makefile.am's in build to distribute the VS2008/2010 project files and associated items required for the build. -Update .gitignore. There needs to be a pre-configured config.h(.win32) and its template, config.h.win32.in for Visual C++ builds https://bugzilla.gnome.org/show_bug.cgi?id=650020 Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-05-12 09:06:32 +00:00
build: Use Makefile.introspection Whenever possible, instead of writing our own rules for generating GIR files and typelibs.
2010-09-03 10:09:57 +00:00
-include $(INTROSPECTION_MAKEFILE)
INTROSPECTION_GIRS =
Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-28 01:02:02 +00:00
if HAVE_INTROSPECTION
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
Cogl-1.0.gir: libcogl.la Makefile
Cogl_1_0_gir_NAMESPACE = Cogl
Cogl_1_0_gir_VERSION = 1.0
Cogl_1_0_gir_LIBS = libcogl.la
Clean up cogl 1.x/2.0 header separation The cogl_public_h variable in cogl/Makefile.am was a mixture of 1.x headers and experimental headers which meant that glib-mkenums was processing lots of experimental api headers. This patch lists experimental api headers under the cogl_experimental_h variable instead. This patch also ensures we undef the COGL_ENABLE_EXPERIMENTAL_* defines when running the gobject introspection scanner for Cogl-1.0.gir Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 22:57:50 +00:00
Cogl_1_0_gir_FILES = $(cogl_1_public_h) cogl-enum-types.h
Cogl_1_0_gir_CFLAGS = $(INCLUDES) $(AM_CPPFLAGS) $(COGL_DEP_CFLAGS) -UCOGL_ENABLE_EXPERIMENTAL_API -UCOGL_ENABLE_EXPERIMENTAL_2_0_API
Adds the ability to build Cogl standalone This adds an autogen.sh, configure.ac and build/autotool files etc under clutter/cogl and makes some corresponding Makefile.am changes that make it possible to build and install Cogl as a standalone library. Some notable things about this are: A standalone installation of Cogl installs 3 pkg-config files; cogl-1.0.pc, cogl-gl-1.0.pc and cogl-2.0.pc. The second is only for compatibility with what clutter installed though I'm not sure that anything uses it so maybe we could remove it. cogl-1.0.pc is what Clutter would use if it were updated to build against a standalone cogl library. cogl-2.0.pc is what you would use if you were writing a standalone Cogl application. A standalone installation results in two libraries currently, libcogl.so and libcogl-pango.so. Notably we don't include a major number in the sonames because libcogl supports two major API versions; 1.x as used by Clutter and the experimental 2.x API for standalone applications. Parallel installation of later versions e.g. 3.x and beyond will be supportable either with new sonames or if we can maintain ABI then we'll continue to share libcogl.so. The headers are similarly not installed into a directory with a major version number since the same headers are shared to export the 1.x and 2.x APIs (The only difference is that cogl-2.0.pc ensures that -DCOGL_ENABLE_EXPERIMENTAL_2_0_API is used). Parallel installation of later versions is not precluded though since we can either continue sharing or later add a major version suffix.
2011-02-10 02:32:11 +00:00
Cogl_1_0_gir_INCLUDES = GL-1.0 GObject-2.0
Cogl_1_0_gir_EXPORT_PACKAGES = cogl-1.0
Cogl_1_0_gir_SCANNERFLAGS = --warn-all --c-include='cogl/cogl.h'
INTROSPECTION_GIRS += Cogl-1.0.gir
Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-28 01:02:02 +00:00
girdir = $(datadir)/gir-1.0
build: Remove gir files from dist The introspection data is going to be generated, so it should never be in the dist.
2010-09-13 01:01:21 +00:00
gir_DATA = $(INTROSPECTION_GIRS)
Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-28 01:02:02 +00:00
build: Compile the introspection data The compilation step for the introspection data was missing.
2011-05-06 15:53:43 +00:00
typelibdir = $(libdir)/girepository-1.0
typelib_DATA = $(INTROSPECTION_GIRS:.gir=.typelib)
CLEANFILES += $(gir_DATA) $(typelib_DATA)
Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-28 01:02:02 +00:00
endif
Reference in New Issue Copy Permalink