isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-29 19:40:43 -05:00
Code Issues Packages Projects Releases Wiki Activity
0fbdafd318
mutter/cogl/Makefile.am

245 lines
7.1 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-27 21:02:02 -04:00
include $(top_srcdir)/build/autotools/Makefile.am.silent
NULL =
cogl: Pull in the code for GLU tesselator from Mesa/SGI This copies the files for the GLU tesselator from Mesa. The Mesa code is based on the original SGI code and is released under a BSD license. The memalloc.h header has been replaced with one that forces the code to use g_malloc and friends. The rest of the files are not altered from the original so it should be possible to later upgrade the files by simply overwriting them. There is a tesselator.h header which is expected to be included by rest of Cogl to use the tesselator. This contains a trimmed down version of glu.h that only includes parts that pertain to the tesselator. There is also a stub glu.h in the GL directory which is just provided so that the tesselator code can include <GL/gl.h> without depending on the system header. It just redirects to tesselator.h
2010-04-15 19:28:15 -04:00
SUBDIRS = driver tesselator
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-27 21:02:02 -04: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 12:35:07 -05:00
BUILT_SOURCES =
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 07:15:25 -04: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-27 21:02:02 -04: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 07:15:25 -04:00
# pkg-config ==================================================================
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-27 21:02:02 -04:00
pc_files = \
cogl-$(COGL_DRIVER)-$(CLUTTER_API_VERSION).pc \
cogl-$(CLUTTER_API_VERSION).pc
cogl-$(CLUTTER_API_VERSION).pc: cogl.pc
$(QUIET_GEN)cp -f $< $(@F)
cogl-$(COGL_DRIVER)-$(CLUTTER_API_VERSION).pc: cogl.pc
$(QUIET_GEN)cp -f $< $(@F)
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = $(pc_files)
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 12:35:07 -05:00
EXTRA_DIST += cogl.pc.in
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 07:15:25 -04:00
CLEANFILES += $(pc_files)
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-27 21:02:02 -04: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 07:15:25 -04:00
-I$(top_srcdir) \
-I$(top_srcdir)/clutter/cogl \
-I$(srcdir)/winsys \
-I$(srcdir)/driver/$(COGL_DRIVER) \
build: Add $(top_buiddir)/clutter/cogl to the include path in clutter/cogl/cogl Some files try to include "cogl/cogl-defines-gl.h" so $(top_builddir)/clutter/cogl needs to be in the include path for out of tree builds to work.
2009-10-27 08:38:10 -04:00
-I$(top_builddir)/clutter/cogl \
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 07:15:25 -04:00
$(NULL)
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-27 21:02:02 -04:00
build: Clean up COGL build flags
2010-01-13 10:40:36 -05:00
AM_CPPFLAGS = \
-DG_DISABLE_SINGLE_INCLUDES \
-DG_DISABLE_DEPRECATED \
-DG_LOG_DOMAIN=\"Cogl-$(COGL_WINSYS)\" \
-DCLUTTER_COMPILATION \
Add -DCOGL_ENABLE_EXPERIMENTAL_API to Makefiles for Cogl and x11/glx Cogl and Clutter should be able to use the experimental API so this adds the required define to the CPPFLAGS in the Makefiles.
2010-06-21 07:48:02 -04:00
-DCOGL_ENABLE_EXPERIMENTAL_API \
build: Clean up COGL build flags
2010-01-13 10:40:36 -05:00
$(COGL_DEBUG_CFLAGS) \
$(CLUTTER_DEBUG_CFLAGS) \
$(NULL)
AM_CFLAGS = $(CLUTTER_CFLAGS) $(MAINTAINER_CFLAGS)
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 12:35:07 -05:00
BUILT_SOURCES += cogl-defines.h
DISTCLEANFILES += cogl-defines.h
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 12:29:08 -04:00
EXTRA_DIST += cogl-defines.h.in
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 07:15:25 -04:00
# public 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-27 21:02:02 -04:00
cogl_public_h = \
build: Distribute cogl-object.h cogl-object.h is a new public header. Include it in the right list of source files to have it distributed.
2010-06-03 06:33:54 -04:00
$(srcdir)/cogl-object.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 07:15:25 -04:00
$(srcdir)/cogl-bitmap.h \
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 12:28:24 -05:00
$(srcdir)/cogl-buffer.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 07:15:25 -04:00
$(srcdir)/cogl-color.h \
$(srcdir)/cogl-debug.h \
$(srcdir)/cogl-fixed.h \
$(srcdir)/cogl-material.h \
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 09:54:44 -04:00
$(srcdir)/cogl-vector.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 07:15:25 -04: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 17:30:37 -05: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 07:15:25 -04:00
$(srcdir)/cogl-path.h \
rename CoglPixelBuffer to CoglPixelArray This renames CoglPixelBuffer to CoglPixelArray to be consistent with the new CoglVertexArray API.
2010-07-03 18:46:03 -04:00
$(srcdir)/cogl-pixel-array.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 07:15:25 -04:00
$(srcdir)/cogl-shader.h \
$(srcdir)/cogl-texture.h \
$(srcdir)/cogl-types.h \
$(srcdir)/cogl-vertex-buffer.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 12:35:07 -05: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-27 21:02:02 -04:00
$(NULL)
build: Clean up COGL build flags
2010-01-13 10:40:36 -05:00
cogl_sources_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 07:15:25 -04:00
$(srcdir)/winsys/cogl-winsys.h \
cogl: Add a struct for winsys-specific data to CoglContext This creates a separate struct to store the fields of the context that are specific to the winsys. This is all stored in one file but ideally this could work more like the CoglContextDriver struct and have a different header for each winsys.
2010-06-02 10:16:14 -04:00
$(srcdir)/winsys/cogl-context-winsys.h \
$(srcdir)/winsys/cogl-context-winsys.c \
cogl: Add the infrastructure for checking for winsys extensions This adds the framework needed to check for winsys specific extensions (such as GLX extensions) using a similar mechanism to the cogl-feature-functions header. There is a separate cogl-winsys-feature-functions header which will contain macros to list the extensions and functions. cogl_create_context_winsys now calls _cogl_feature_check for each of these functions. _cogl_feature_check has had to be changed to accept the driver prefix as the first parameter so that it can prepend "GLX" rather than "GL" in this case.
2010-06-02 12:55:56 -04:00
$(srcdir)/winsys/cogl-winsys-feature-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 07:15:25 -04:00
$(srcdir)/cogl-handle.h \
$(srcdir)/cogl-context.h \
$(srcdir)/cogl-context.c \
$(srcdir)/cogl-internal.h \
$(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 17:24:56 -04: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 07:15:25 -04:00
$(srcdir)/cogl-util.h \
$(srcdir)/cogl-util.c \
$(srcdir)/cogl-bitmap-private.h \
$(srcdir)/cogl-bitmap.c \
$(srcdir)/cogl-bitmap-fallback.c \
$(srcdir)/cogl-primitives.h \
$(srcdir)/cogl-primitives.c \
cogl: Support retained paths This adds three new API calls: CoglHandle cogl_path_get() void cogl_path_set(CoglHandle path) CoglHandle cogl_path_copy(CoglHandle path) All of the fields relating to the path have been moved from the Cogl context to a new CoglPath handle type. The cogl context now just contains a CoglPath handle. All of the existing path commands manipulate the data in the current path handle. cogl_path_new now just creates a new path handle and unrefs the old one. The path handle can be stored for later with cogl_path_get. The path can then be copied with cogl_path_copy. Internally it implements copy-on-write semantics with an extra optimisation that it will only copy the data if the new path is modified, but not if the original path is modified. It can do this because the only way to modify a path is by appending to it so the copied path is able to store its own path length and only render the nodes up to that length. For this to work the copied path also needs to keep its own copies of the path extents because the parent path may change these by adding nodes. The clip stack now uses the cogl_path_copy mechanism to store paths in the stack instead of directly copying the data. This should save some memory and processing time.
2010-04-08 12:43:27 -04: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 17:30:37 -05:00
$(srcdir)/cogl-path.h \
$(srcdir)/cogl-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 07:15:25 -04:00
$(srcdir)/cogl-bitmap-pixbuf.c \
$(srcdir)/cogl-clip-stack.h \
$(srcdir)/cogl-clip-stack.c \
Separate out CoglClipStackState from cogl-clip-stack.c CoglClipStackState has now been renamed to CoglClipState and is moved to a separate file. CoglClipStack now just maintains a stack and doesn't worry about the rest of the state. CoglClipStack sill contains the code to flush the stack to GL.
2010-04-14 14:41:08 -04:00
$(srcdir)/cogl-clip-state.h \
$(srcdir)/cogl-clip-state.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 08:52:40 -05: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 07:15:25 -04: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 17:36:19 -04: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 07:15:25 -04: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 12:28:24 -05:00
$(srcdir)/cogl-buffer-private.h \
$(srcdir)/cogl-buffer.c \
rename CoglPixelBuffer to CoglPixelArray This renames CoglPixelBuffer to CoglPixelArray to be consistent with the new CoglVertexArray API.
2010-07-03 18:46:03 -04:00
$(srcdir)/cogl-pixel-array-private.h \
$(srcdir)/cogl-pixel-array.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 07:15:25 -04:00
$(srcdir)/cogl-vertex-buffer-private.h \
$(srcdir)/cogl-vertex-buffer.c \
$(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 09:54:44 -04:00
$(srcdir)/cogl-vector.c \
build: Add cogl-matrix-private.h to the dist
2009-11-18 09:37:43 -05: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 07:15:25 -04:00
$(srcdir)/cogl-matrix-stack.c \
$(srcdir)/cogl-matrix-stack.h \
$(srcdir)/cogl-material.c \
$(srcdir)/cogl-material-private.h \
material: Split the fragment processing backends out This splits the fragment processing backends (glsl, arbfp and fixed) out from cogl-material.c into their own cogl-material-{glsl,arbfp,fixed}.c files in an effort to help and keep cogl-material.c maintainable.
2010-06-15 11:44:52 -04:00
$(srcdir)/cogl-material-glsl.c \
$(srcdir)/cogl-material-glsl-private.h \
$(srcdir)/cogl-material-arbfp.c \
$(srcdir)/cogl-material-arbfp-private.h \
$(srcdir)/cogl-material-fixed.c \
$(srcdir)/cogl-material-fixed-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 07:15:25 -04: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 11:39:16 -05: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 07:15:25 -04: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 13:45:36 -05: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 07:15:25 -04:00
$(srcdir)/cogl-texture-2d-sliced-private.h \
$(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 11:39:16 -05: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 07:15:25 -04:00
$(srcdir)/cogl-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 13:45:36 -05: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 07:15:25 -04:00
$(srcdir)/cogl-texture-2d-sliced.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 10:33:34 -04:00
$(srcdir)/cogl-texture-rectangle-private.h \
$(srcdir)/cogl-texture-rectangle.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 08:06:32 -05:00
$(srcdir)/cogl-atlas.h \
$(srcdir)/cogl-atlas.c \
$(srcdir)/cogl-atlas-texture-private.h \
$(srcdir)/cogl-atlas-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 07:15:25 -04: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 14:06:35 -05:00
$(srcdir)/cogl-framebuffer-private.h \
$(srcdir)/cogl-framebuffer.c \
[cogl-matrix] Import Mesa's matrix manipulation code This pulls in code from Mesa to improve our matrix manipulation support. It includes support for calculating the inverse of matrices based on top of a matrix categorizing system that allows optimizing certain matrix types. (the main thing we were after) but also adds some optimisations for rotations. Changes compared to the original code from Mesa: - Coding style is consistent with the rest of Cogl - Instead of allocating matrix->m and matrix->inv using malloc, our public CoglMatrix typedef is large enough to directly contain the matrix, its inverse, a type and a set of flags. - Instead of having a _math_matrix_analyse which updates the type, flags and inverse, we have _math_matrix_update_inverse which essentially does the same thing (internally making use of _math_matrix_update_type_and_flags()) but with additional guards in place to bail out when the inverse matrix is still valid. - When initializing a matrix with the identity matrix we don't immediately initialize the inverse matrix; rather we just set the dirty flag for the inverse (since it's likely the user won't request the inverse of the identity matrix)
2009-10-26 04:23:21 -04:00
$(srcdir)/cogl-matrix-mesa.h \
$(srcdir)/cogl-matrix-mesa.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 11:22:35 -04:00
$(srcdir)/cogl-profile.h \
$(srcdir)/cogl-profile.c \
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 12:31:42 -04:00
$(srcdir)/cogl-bitmask.h \
$(srcdir)/cogl-bitmask.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-27 21:02:02 -04:00
$(NULL)
build: Clean up COGL build flags
2010-01-13 10:40:36 -05:00
# glib-mkenums rules
glib_enum_h = cogl-enum-types.h
glib_enum_c = cogl-enum-types.c
glib_enum_headers = $(cogl_public_h)
include $(top_srcdir)/build/autotools/Makefile.am.enums
noinst_LTLIBRARIES = libclutter-cogl.la
cogl: Pull in the code for GLU tesselator from Mesa/SGI This copies the files for the GLU tesselator from Mesa. The Mesa code is based on the original SGI code and is released under a BSD license. The memalloc.h header has been replaced with one that forces the code to use g_malloc and friends. The rest of the files are not altered from the original so it should be possible to later upgrade the files by simply overwriting them. There is a tesselator.h header which is expected to be included by rest of Cogl to use the tesselator. This contains a trimmed down version of glu.h that only includes parts that pertain to the tesselator. There is also a stub glu.h in the GL directory which is just provided so that the tesselator code can include <GL/gl.h> without depending on the system header. It just redirects to tesselator.h
2010-04-15 19:28:15 -04:00
libclutter_cogl_la_LIBADD = \
-lm $(CLUTTER_LIBS) \
$(top_builddir)/clutter/cogl/cogl/driver/$(COGL_DRIVER)/libclutter-cogl-driver.la \
$(top_builddir)/clutter/cogl/cogl/tesselator/libtesselator.la
build: Clean up COGL build flags
2010-01-13 10:40:36 -05:00
build: Exclude built sources from the dist http://bugzilla.clutter-project.org/show_bug.cgi?id=2169 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2010-07-06 08:24:00 -04:00
libclutter_cogl_la_SOURCES = $(cogl_sources_c)
nodist_libclutter_cogl_la_SOURCES = $(BUILT_SOURCES)
build: Clean up COGL build flags
2010-01-13 10:40:36 -05:00
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 11:13:07 -04:00
if SUPPORT_XLIB
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 13:56:14 -04:00
cogl_public_h += \
$(srcdir)/winsys/cogl-texture-pixmap-x11.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 07:08:21 -04:00
libclutter_cogl_la_SOURCES += \
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 11:13:07 -04:00
$(srcdir)/winsys/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 13:56:14 -04:00
$(srcdir)/winsys/cogl-xlib.c \
$(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 07:08:21 -04: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 11:13:07 -04:00
if SUPPORT_GLX
libclutter_cogl_la_SOURCES += \
$(srcdir)/winsys/cogl-glx.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 07:08:21 -04:00
if SUPPORT_EGL_PLATFORM_POWERVR_X11
libclutter_cogl_la_SOURCES += \
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 11:13:07 -04:00
$(srcdir)/winsys/cogl-egl.c
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 07:08:21 -04:00
endif
if SUPPORT_EGL_PLATFORM_POWERVR_NULL
libclutter_cogl_la_SOURCES += \
egl: Consolidates eglx and eglnative into one "egl" winsys This remove quite a lot of redundant code by consolidating the eglx and eglnative window system backends.
2010-06-17 23:38:43 -04:00
$(srcdir)/winsys/cogl-egl.c
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 07:08:21 -04:00
endif
if SUPPORT_EGL_PLATFORM_FRUITY
libclutter_cogl_la_SOURCES += \
$(srcdir)/winsys/cogl-fruity.c
endif
if SUPPORT_WIN32
libclutter_cogl_la_SOURCES += \
$(srcdir)/winsys/cogl-win32.c
endif
if SUPPORT_OSX
libclutter_cogl_la_SOURCES += \
$(srcdir)/winsys/cogl-osx.c
endif
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 07:15:25 -04: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-27 21:02:02 -04:00
# COGL installed headers
cogl_headers = \
$(cogl_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 07:15:25 -04:00
$(srcdir)/cogl-deprecated.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-27 21:02:02 -04:00
$(NULL)
coglincludedir = $(includedir)/clutter-@CLUTTER_API_VERSION@/cogl
coglinclude_HEADERS = $(cogl_headers)
build: Exclude built sources from the dist http://bugzilla.clutter-project.org/show_bug.cgi?id=2169 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2010-07-06 08:24:00 -04:00
nodist_coglinclude_HEADERS = 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-27 21:02:02 -04:00
if HAVE_INTROSPECTION
cally: Add introspection generation Toolkits and applications not written in C might still need access to the Cally API to write accessibility extensions based on it for their own native elements.
2010-07-07 10:57:43 -04:00
Cogl-@CLUTTER_API_VERSION@.gir: Makefile $(INTROSPECTION_SCANNER) libclutter-cogl.la
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-27 21:02:02 -04:00
$(QUIET_GEN)$(INTROSPECTION_SCANNER) -v \
--namespace Cogl --nsversion=@CLUTTER_API_VERSION@ \
build: Clean up COGL build flags
2010-01-13 10:40:36 -05:00
$(INCLUDES) \
$(AM_CPPFLAGS) \
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-27 21:02:02 -04:00
--c-include='cogl/cogl.h' \
--include=GL-1.0 \
--include=GObject-2.0 \
--library=libclutter-cogl.la \
--libtool="$(top_builddir)/libtool" \
--pkg gobject-2.0 \
--output $@ \
build: Exclude built sources from the dist http://bugzilla.clutter-project.org/show_bug.cgi?id=2169 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2010-07-06 08:24:00 -04:00
$(cogl_headers) 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-27 21:02:02 -04:00
BUILT_GIRSOURCES = Cogl-@CLUTTER_API_VERSION@.gir
girdir = $(datadir)/gir-1.0
gir_DATA = $(BUILT_GIRSOURCES)
CLEANFILES += $(BUILT_GIRSOURCES)
endif
Reference in New Issue Copy Permalink