From a84a30cda2a860aa6c4b56597cdc61c6ac8d197d Mon Sep 17 00:00:00 2001 From: =?utf8?q?Rafa=C5=82=20D=C5=82ugo=C5=82=C4=99cki?= Date: Tue, 21 Jan 2014 12:07:52 +0100 Subject: [PATCH] Added autoconf archive as submodule, due to its ax_check_gl* m4 macros. Added macros to my code.. --- .gitmodules | 3 + m4/ax_check_gl.m4 | 482 ++++++++++++++++++++++++++++++++++++++++ m4/ax_check_glu.m4 | 382 +++++++++++++++++++++++++++++++ vendor/autoconf-archive | 1 + 4 files changed, 868 insertions(+) create mode 100644 .gitmodules create mode 100644 m4/ax_check_gl.m4 create mode 100644 m4/ax_check_glu.m4 create mode 160000 vendor/autoconf-archive diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..9b2a20c --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "vendor/autoconf-archive"] + path = vendor/autoconf-archive + url = git://git.sv.gnu.org/autoconf-archive.git diff --git a/m4/ax_check_gl.m4 b/m4/ax_check_gl.m4 new file mode 100644 index 0000000..964220d --- /dev/null +++ b/m4/ax_check_gl.m4 @@ -0,0 +1,482 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_check_gl.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_CHECK_GL +# +# DESCRIPTION +# +# Check for an OpenGL implementation. If GL is found, the required +# compiler and linker flags are included in the output variables +# "GL_CFLAGS", "GL_LIBS", "GL_LDFLAGS", respectively. If no usable GL +# implementation is found, "no_gl" is set to "yes". +# +# You could disable OpenGL using --with-gl=no +# +# You could choose a specific OpenGL libs using --with-gl=lib_name +# +# Under darwin, cygwin and mingw target you could prefer the OpenGL +# implementation that link with X setting --with-gl=x or without X support +# with --with-gl=nox. Notes that this script try to guess the right +# implementation. +# +# If the header "GL/gl.h" is found, "HAVE_GL_GL_H" is defined. If the +# header "OpenGL/gl.h" is found, HAVE_OPENGL_GL_H is defined. These +# preprocessor definitions may not be mutually exclusive. +# +# You should use something like this in your headers: +# +# #if defined(HAVE_WINDOWS_H) && defined(_WIN32) +# # include +# #endif +# #ifdef HAVE_GL_GL_H +# # include +# #elif defined(HAVE_OPENGL_GL_H) +# # include +# #else +# # error no gl.h +# #endif +# +# LICENSE +# +# Copyright (c) 2009 Braden McDaniel +# Copyright (c) 2012 Bastien Roucaries +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation; either version 2 of the License, or (at your +# option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program. If not, see . +# +# As a special exception, the respective Autoconf Macro's copyright owner +# gives unlimited permission to copy, distribute and modify the configure +# scripts that are the output of Autoconf when processing the Macro. You +# need not follow the terms of the GNU General Public License when using +# or distributing such scripts, even though portions of the text of the +# Macro appear in them. The GNU General Public License (GPL) does govern +# all other use of the material that constitutes the Autoconf Macro. +# +# This special exception to the GPL applies to versions of the Autoconf +# Macro released by the Autoconf Archive. When you make and distribute a +# modified version of the Autoconf Macro, you may extend this special +# exception to the GPL to apply to your modified version as well. + +#serial 15 + +m4_define([_AX_CHECK_GL_PROGRAM], + [AC_LANG_PROGRAM([[ +# if defined(HAVE_WINDOWS_H) && defined(_WIN32) +# include +# endif +# ifdef HAVE_GL_GL_H +# include +# elif defined(HAVE_OPENGL_GL_H) +# include +# else +# error no gl.h +# endif +]],[[glBegin(0)]])]) + +dnl Default include : add windows.h +dnl see http://www.opengl.org/wiki/Platform_specifics:_Windows +dnl (acceded 20120801) +AC_DEFUN([_AX_CHECK_GL_INCLUDES_DEFAULT],dnl +[ + AC_INCLUDES_DEFAULT + [ + # if defined(HAVE_WINDOWS_H) && defined(_WIN32) + # include + # endif + ] +]) + +dnl local save flags +AC_DEFUN([_AX_CHECK_GL_SAVE_FLAGS], +[dnl +ax_check_gl_saved_libs="${LIBS}" +ax_check_gl_saved_cflags="${CFLAGS}" +ax_check_gl_saved_cppflags="${CPPFLAGS}" +ax_check_gl_saved_ldflags="${LDFLAGS}" +]) + +dnl local restore flags +AC_DEFUN([_AX_CHECK_GL_RESTORE_FLAGS], +[dnl +LIBS="${ax_check_gl_saved_libs}" +CFLAGS="${ax_check_gl_saved_cflags}" +CPPFLAGS="${ax_check_gl_saved_cppflags}" +LDFLAGS="${ax_check_gl_saved_ldflags}" +]) + +# set the varible ax_check_gl_need_x +# this variable determine if we need opengl that link with X +# value are default aka try the first library wether if it link or not with x +# yes that means we need a opengl with x +# no that means we do not need an opengl with x +AC_DEFUN([_AX_CHECK_GL_NEED_X], +[dnl + # do not check if empty : allow a subroutine to modify the choice + AS_IF([test "X$ax_check_gl_need_x" = "X"], + [ax_check_gl_need_x="default" + AS_IF([test "X$no_x" = "Xyes"],[ax_check_gl_need_x="no"]) + AS_IF([test "X$ax_check_gl_want_gl" = "Xnox"],[ax_check_gl_need_x="no"]) + AS_IF([test "X$ax_check_gl_want_gl" = "Xx"],[ax_check_gl_need_x="yes"])]) +]) + +# compile the example program +AC_DEFUN([_AX_CHECK_GL_COMPILE], +[dnl + AC_LANG_PUSH([C]) + _AX_CHECK_GL_SAVE_FLAGS() + CFLAGS="${GL_CFLAGS} ${CFLAGS}" + AC_COMPILE_IFELSE([_AX_CHECK_GL_PROGRAM], + [ax_check_gl_compile_opengl="yes"], + [ax_check_gl_compile_opengl="no"]) + _AX_CHECK_GL_RESTORE_FLAGS() + AC_LANG_POP([C]) +]) + +# compile the example program (cache) +AC_DEFUN([_AX_CHECK_GL_COMPILE_CV], +[dnl + AC_CACHE_CHECK([for compiling a minimal OpenGL program],[ax_cv_check_gl_compile_opengl], + [_AX_CHECK_GL_COMPILE() + ax_cv_check_gl_compile_opengl="${ax_check_gl_compile_opengl}"]) + ax_check_gl_compile_opengl="${ax_cv_check_gl_compile_opengl}" +]) + +# link the example program +AC_DEFUN([_AX_CHECK_GL_LINK], +[dnl + AC_LANG_PUSH([C]) + _AX_CHECK_GL_SAVE_FLAGS() + CFLAGS="${GL_CFLAGS} ${CFLAGS}" + LIBS="${GL_LIBS} ${LIBS}" + LDFLAGS="${GL_LDFLAGS} ${LDFLAGS}" + AC_LINK_IFELSE([_AX_CHECK_GL_PROGRAM], + [ax_check_gl_link_opengl="yes"], + [ax_check_gl_link_opengl="no"]) + _AX_CHECK_GL_RESTORE_FLAGS() + AC_LANG_POP([C]) +]) + +# link the example program (cache) +AC_DEFUN([_AX_CHECK_GL_LINK_CV], +[dnl + AC_CACHE_CHECK([for linking a minimal OpenGL program],[ax_cv_check_gl_link_opengl], + [_AX_CHECK_GL_LINK() + ax_cv_check_gl_link_opengl="${ax_check_gl_link_opengl}"]) + ax_check_gl_link_opengl="${ax_cv_check_gl_link_opengl}" +]) + +dnl Check headers manually (default case) +AC_DEFUN([_AX_CHECK_GL_MANUAL_HEADERS_DEFAULT], +[AC_REQUIRE([AC_PATH_XTRA]) + AC_LANG_PUSH([C]) + _AX_CHECK_GL_SAVE_FLAGS() + CFLAGS="${GL_CFLAGS} ${CFLAGS}" + # see comment in _AX_CHECK_GL_INCLUDES_DEFAULT + AC_CHECK_HEADERS([windows.h],[],[],[AC_INCLUDES_DEFAULT]) + # FIXME: use extra cflags + AC_CHECK_HEADERS([GL/gl.h],[ax_check_gl_have_headers="yes"], + [ax_check_gl_have_headers_headers="no"], + [_AX_CHECK_GL_INCLUDES_DEFAULT()]) + # do not try darwin specific OpenGl/gl.h + _AX_CHECK_GL_RESTORE_FLAGS() + AC_LANG_POP([C]) +]) + +# darwin headers without X +AC_DEFUN([_AX_CHECK_GL_MANUAL_HEADERS_DARWIN_NOX],[ + AC_LANG_PUSH([C]) + _AX_CHECK_GL_SAVE_FLAGS() + # FIXME: use -framework opengl as an extra cflags + CFLAGS="-framework opengl ${GL_CFLAGS} ${CFLAGS}" + AC_CHECK_HEADERS([OpenGL/gl.h],[ax_check_gl_have_headers="yes"], + [ax_check_gl_have_headers_headers="no"], + [_AX_CHECK_GL_INCLUDES_DEFAULT()]) + AS_IF([test "X$ax_check_gl_have_headers" = "yes"], + [GL_CFLAGS="-framework opengl ${GL_CFLAGS}"]) + _AX_CHECK_GL_SAVE_FLAGS() + AC_LANG_POP([C]) +]) + +# check header for darwin +AC_DEFUN([_AX_CHECK_GL_MANUAL_HEADERS_DARWIN], +[AC_REQUIRE([_AX_CHECK_GL_NEED_X])dnl + AS_CASE([$ax_check_gl_need_x], + # try to get X libs if possible do not use framework + [yes],[_AX_CHECK_GL_MANUAL_HEADERS_DEFAULT()] + [no],[_AX_CHECK_GL_MANUAL_HEADERS_DARWIN_NOX()] + # per default use framework that will select if possible no_x version + [_AX_CHECK_GL_MANUAL_HEADERS_DARWIN_NOX() + # if not found set that we need x in order to found the good library + AS_IF([test "X$ax_check_gl_have_headers" = "yes"], + [ax_check_gl_need_x="no"], + [ax_check_gl_need_x="yes" + # retry with general test + _AX_CHECK_GL_MANUAL_HEADERS_DEFAULT()]) + ]) +]) + +dnl Check headers manually: subroutine must set ax_check_gl_have_headers={yes,no} +AC_DEFUN([_AX_CHECK_GL_MANUAL_HEADERS], +[AC_REQUIRE([AC_CANONICAL_HOST]) + AS_CASE([${host}], + [*-darwin*],[_AX_CHECK_GL_MANUAL_HEADERS_DARWIN], + [_AX_CHECK_GL_MANUAL_HEADERS_DEFAULT()]) + AC_CACHE_CHECK([for OpenGL headers],[ax_cv_check_gl_have_headers], + [ax_cv_check_gl_have_headers="${ax_check_gl_have_headers}"]) +]) + +# dnl try to found library (generic case) +# dnl $1 is set to the library to found +AC_DEFUN([_AX_CHECK_GL_MANUAL_LIBS_GENERIC], +[dnl + ax_check_gl_manual_libs_generic_extra_libs="$1" + AS_IF([test "X$ax_check_gl_manual_libs_generic_extra_libs" = "X"], + [AC_MSG_ERROR([AX_CHECK_GL_MANUAL_LIBS_GENERIC argument must no be empty])]) + + AC_LANG_PUSH([C]) + _AX_CHECK_GL_SAVE_FLAGS() + CFLAGS="${GL_CFLAGS} ${CFLAGS}" + LIBS="${GL_LIBS} ${LIBS}" + AC_SEARCH_LIBS([glBegin],[$ax_check_gl_manual_libs_generic_extra_libs], + [ax_check_gl_lib_opengl="yes"], + [ax_check_gl_lib_opengl="no"]) + AS_CASE([$ac_cv_search_glBegin], + ["none required"],[], + [no],[], + [GL_LIBS="${ac_cv_search_glBegin} ${GL_LIBS}"]) + _AX_CHECK_GL_RESTORE_FLAGS() + AC_LANG_PUSH([C]) +]) + +# dnl try to found lib under darwin +# darwin opengl hack +# see http://web.archive.org/web/20090410052741/http://developer.apple.com/qa/qa2007/qa1567.html +# and http://web.eecs.umich.edu/~sugih/courses/eecs487/glut-howto/ +AC_DEFUN([_AX_CHECK_GL_MANUAL_LIBS_DARWIN], +[# ldhack list + ldhack1 = "-Wl,-framework,OpenGL" + ldhack2 = "-Wl,-dylib_file,/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib:/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib" + ldhack3 = "$ldhack1,$ldhack2" + + # select hack + AS_IF([test "X$ax_check_gl_need_x" = "Xyes"], + [# libs already set by -framework cflag + darwinlibs="" + ldhacks="$ldhack1 $ldhack2 $ldhack3"], + [# do not use framework ldflags in case of x version + darwinlibs="GL gl MesaGL" + ldhack="$ldhack2"]) + + ax_check_gl_link_opengl="no" + for extralibs in " " $darwinlibs; do + for extraldflags in " " ldhacks; do + AC_LANG_PUSH([C]) + _AX_CHECK_GL_SAVE_FLAGS() + CFLAGS="${GL_CFLAGS} ${CFLAGS}" + LIBS="$extralibs ${GL_LIBS} ${LIBS}" + LDFLAGS="$extraldflags ${GL_LDFLAGS} ${LDFLAGS}" + AC_LINK_IFELSE([_AX_CHECK_GL_PROGRAM], + [ax_check_gl_link_opengl="yes"], + [ax_check_gl_link_opengl="no"]) + _AX_CHECK_GL_RESTORE_FLAGS() + AC_LANG_POP([C]) + AS_IF([test "X$ax_check_gl_link_opengl" = "Xyes"],[break]) + done; + AS_IF([test "X$ax_check_gl_link_opengl" = "Xyes"],[break]) + done; + GL_LIBS="$extralibs ${GL_LIBS}" + GL_LDFLAGS="$extraldflags ${GL_LDFLAGS}" +]) + +dnl Check library manually: subroutine must set +dnl $ax_check_gl_lib_opengl={yes,no} +AC_DEFUN([_AX_CHECK_GL_MANUAL_LIBS], +[AC_REQUIRE([AC_CANONICAL_HOST]) + AS_CASE([${host}], + [*-darwin*],[_AX_CHECK_GL_MANUAL_LIBS_DARWIN()], + # try first cygwin version + [*-cygwin*],[_AX_CHECK_GL_MANUAL_LIBS_GENERIC([GL gl MesaGL opengl32])], + # try first native + [*-mingw*],[_AX_CHECK_GL_MANUAL_LIBS_GENERIC([opengl32 GL gl MesaGL])], + [_AX_CHECK_GL_MANUAL_LIBS_GENERIC([GL gl MesaGL])]) + + AC_CACHE_CHECK([for OpenGL libraries],[ax_cv_check_gl_lib_opengl], + [ax_cv_check_gl_lib_opengl="${ax_check_gl_lib_opengl}"]) + ax_check_gl_lib_opengl="${ax_cv_check_gl_lib_opengl}" +]) + +# manually check aka old way +AC_DEFUN([_AX_CHECK_GL_MANUAL], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl + AC_REQUIRE([AC_PATH_XTRA])dnl + + no_gl="yes" + + _AX_CHECK_GL_MANUAL_HEADERS() + AS_IF([test "X$ax_check_gl_have_headers" = "Xyes"], + [_AX_CHECK_GL_COMPILE_CV()], + [ax_check_gl_compile_opengl=no]) + + AS_IF([test "X$ax_check_gl_compile_opengl" = "Xyes"], + [_AX_CHECK_GL_MANUAL_LIBS], + [ax_check_gl_lib_opengl=no]) + + AS_IF([test "X$ax_check_gl_lib_opengl" = "Xyes"], + [_AX_CHECK_GL_LINK_CV()], + [ax_check_gl_link_opengl=no]) + + AS_IF([test "X$ax_check_gl_link_opengl" = "Xyes"], + [no_gl="no"], + [no_gl="yes"]) +])dnl + + +# try to test using pkgconfig: set ax_check_gl_pkg_config=no if not found +AC_DEFUN([_AX_CHECK_GL_PKG_CONFIG],dnl +[dnl + AC_REQUIRE([PKG_PROG_PKG_CONFIG]) + + PKG_CHECK_MODULES([GL],[gl],[ax_check_gl_pkg_config=yes],[ax_check_gl_pkg_config=no]) + AS_IF([test "X$ax_check_gl_pkg_config" = "Xyes"],[ + # check headers + AC_LANG_PUSH([C]) + _AX_CHECK_GL_SAVE_FLAGS() + CFLAGS="${GL_CFLAGS} ${CFLAGS}" + AC_CHECK_HEADERS([windows.h],[],[],[AC_INCLUDES_DEFAULT]) + AC_CHECK_HEADERS([GL/gl.h OpenGL/gl.h], + [ax_check_gl_have_headers="yes";break], + [ax_check_gl_have_headers_headers="no"], + [_AX_CHECK_GL_INCLUDES_DEFAULT()]) + _AX_CHECK_GL_RESTORE_FLAGS() + AC_LANG_POP([C]) + AC_CACHE_CHECK([for OpenGL headers],[ax_cv_check_gl_have_headers], + [ax_cv_check_gl_have_headers="${ax_check_gl_have_headers}"]) + + # pkgconfig library are suposed to work ... + AS_IF([test "X$ax_cv_check_gl_have_headers" = "Xno"], + [AC_MSG_ERROR("Pkgconfig detected OpenGL library has no headers!")]) + + _AX_CHECK_GL_COMPILE_CV() + AS_IF([test "X$ax_cv_check_gl_compile_opengl" = "Xno"], + [AC_MSG_ERROR("Pkgconfig detected opengl library could not be used for compiling minimal program!")]) + + _AX_CHECK_GL_LINK_CV() + AS_IF([test "X$ax_cv_check_gl_link_opengl" = "Xno"], + [AC_MSG_ERROR("Pkgconfig detected opengl library could not be used for linking minimal program!")]) + ]) +]) + +# test if gl link with X +AC_DEFUN([_AX_CHECK_GL_WITH_X], +[ + # try if opengl need X + AC_LANG_PUSH([C]) + _AX_CHECK_GL_SAVE_FLAGS() + CFLAGS="${GL_CFLAGS} ${CFLAGS}" + LIBS="${GL_LIBS} ${LIBS}" + LDFLAGS="${GL_LDFLAGS} ${LDFLAGS}" + AC_LINK_IFELSE([AC_LANG_CALL([], [glXQueryVersion])], + [ax_check_gl_link_implicitly_with_x="yes"], + [ax_check_gl_link_implicitly_with_x="no"]) + _AX_CHECK_GL_RESTORE_FLAGS() + AC_LANG_POP([C]) +]) + +# internal routine: entry point if gl not disable +AC_DEFUN([_AX_CHECK_GL],[dnl + AC_REQUIRE([PKG_PROG_PKG_CONFIG]) + AC_REQUIRE([AC_PATH_X])dnl + + # does we need X or not + _AX_CHECK_GL_NEED_X() + + # try first pkgconfig + AC_MSG_CHECKING([for a working OpenGL implementation by pkg-config]) + AS_IF([test "X${PKG_CONFIG}" = "X"], + [ AC_MSG_RESULT([no]) + ax_check_gl_pkg_config=no], + [ AC_MSG_RESULT([yes]) + _AX_CHECK_GL_PKG_CONFIG()]) + + # if no pkgconfig or pkgconfig fail try manual way + AS_IF([test "X$ax_check_gl_pkg_config" = "Xno"], + [_AX_CHECK_GL_MANUAL()], + [no_gl=no]) + + + # test if need to test X compatibility + AS_IF([test $no_gl = no], + [# test X compatibility + AS_IF([test X$ax_check_gl_need_x != "Xdefault"], + [AC_CACHE_CHECK([wether OpenGL link implictly with X],[ax_cv_check_gl_link_with_x], + [_AX_CHECK_GL_WITH_X() + ax_cv_check_gl_link_with_x="${ax_check_gl_link_implicitly_with_x}"]) + AS_IF([test "X${ax_cv_check_gl_link_with_x}" = "X${ax_check_gl_need_x}"], + [no_gl="no"], + [no_gl=yes])]) + ]) +]) + +# ax_check_gl entry point +AC_DEFUN([AX_CHECK_GL], +[AC_REQUIRE([AC_PATH_X])dnl + + AC_ARG_WITH([gl], + [AS_HELP_STRING([--with-gl@<:@=ARG@:>@], + [use opengl (ARG=yes), + using the specific lib (ARG=), + using the OpenGL lib that link with X (ARG=x), + using the OpenGL lib that link without X (ARG=nox), + or disable it (ARG=no) + @<:@ARG=yes@:>@ ])], + [ + AS_CASE(["$withval"], + ["no"|"NO"],[ax_check_gl_want_gl="no"], + ["yes"|"YES"],[ax_check_gl_want_gl="yes"], + [ax_check_gl_want_gl="$withval"]) + ], + [ax_check_gl_want_gl="yes"]) + + # check consistency of parameters + AS_IF([test "X$have_x" = "Xdisabled"], + [AS_IF([test X$ax_check_gl_want_gl = "Xx"], + [AC_MSG_ERROR([You prefer OpenGL with X and asked for no X support])])]) + + # set flags + no_gl="yes" + + # now do the real testing + AS_IF([test X$ax_check_gl_want_gl != "Xno"], + [_AX_CHECK_GL()]) + + AC_MSG_CHECKING([for a working OpenGL implementation]) + AS_IF([test "X$no_gl" = "Xno"], + [AC_MSG_RESULT([yes]) + AC_MSG_CHECKING([for CFLAGS needed for OpenGL]) + AC_MSG_RESULT(["${GL_CFLAGS}"]) + AC_MSG_CHECKING([for LIBS needed for OpenGL]) + AC_MSG_RESULT(["${GL_LIBS}"]) + AC_MSG_CHECKING([for LDFLAGS needed for OpenGL]) + AC_MSG_RESULT(["${GL_LDFLAGS}"])], + [AC_MSG_RESULT([no]) + GL_CFLAGS="" + GL_LIBS="" + GL_LDFLAGS=""]) + + AC_SUBST([GL_CFLAGS]) + AC_SUBST([GL_LIBS]) + AC_SUBST([GL_LDFLAGS]) +]) diff --git a/m4/ax_check_glu.m4 b/m4/ax_check_glu.m4 new file mode 100644 index 0000000..5561a92 --- /dev/null +++ b/m4/ax_check_glu.m4 @@ -0,0 +1,382 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_check_glu.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_CHECK_GLU +# +# DESCRIPTION +# +# Check for GLU. If GLU is found, the required preprocessor and linker +# flags are included in the output variables "GLU_CFLAGS" and "GLU_LIBS", +# respectively. If no GLU implementation is found, "no_glu" is set to +# "yes". +# +# If the header "GL/glu.h" is found, "HAVE_GL_GLU_H" is defined. If the +# header "OpenGL/glu.h" is found, HAVE_OPENGL_GLU_H is defined. These +# preprocessor definitions may not be mutually exclusive. +# +# You should use something like this in your headers: +# +# # if defined(HAVE_WINDOWS_H) && defined(_WIN32) +# # include +# # endif +# # if defined(HAVE_GL_GLU_H) +# # include +# # elif defined(HAVE_OPENGL_GLU_H) +# # include +# # else +# # error no glu.h +# # endif +# +# Some implementations (in particular, some versions of Mac OS X) are +# known to treat the GLU tesselator callback function type as "GLvoid +# (*)(...)" rather than the standard "GLvoid (*)()". If the former +# condition is detected, this macro defines "HAVE_VARARGS_GLU_TESSCB". +# +# LICENSE +# +# Copyright (c) 2009 Braden McDaniel +# Copyright (c) 2013 Bastien Roucaries +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation; either version 2 of the License, or (at your +# option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program. If not, see . +# +# As a special exception, the respective Autoconf Macro's copyright owner +# gives unlimited permission to copy, distribute and modify the configure +# scripts that are the output of Autoconf when processing the Macro. You +# need not follow the terms of the GNU General Public License when using +# or distributing such scripts, even though portions of the text of the +# Macro appear in them. The GNU General Public License (GPL) does govern +# all other use of the material that constitutes the Autoconf Macro. +# +# This special exception to the GPL applies to versions of the Autoconf +# Macro released by the Autoconf Archive. When you make and distribute a +# modified version of the Autoconf Macro, you may extend this special +# exception to the GPL to apply to your modified version as well. + +#serial 16 + +# exemple program +m4_define([_AX_CHECK_GLU_PROGRAM], + [AC_LANG_PROGRAM([[ +# if defined(HAVE_WINDOWS_H) && defined(_WIN32) +# include +# endif +# ifdef HAVE_GL_GLU_H +# include +# elif defined(HAVE_OPENGL_GLU_H) +# include +# else +# error no glu.h +# endif +]],[[gluBeginCurve(0)]])]) + + +dnl Default include : add windows.h +dnl see http://www.opengl.org/wiki/Platform_specifics:_Windows +dnl (acceded 20120801) +AC_DEFUN([_AX_CHECK_GLU_INCLUDES_DEFAULT],dnl +[ + AC_INCLUDES_DEFAULT + [ + # if defined(HAVE_WINDOWS_H) && defined(_WIN32) + # include + # endif + ] +]) + +dnl local save flags +AC_DEFUN([_AX_CHECK_GLU_SAVE_FLAGS], +[dnl +ax_check_glu_saved_libs="${LIBS}" +ax_check_glu_saved_cflags="${CFLAGS}" +ax_check_glu_saved_cppflags="${CPPFLAGS}" +ax_check_glu_saved_ldflags="${LDFLAGS}" +]) + + +dnl local restore flags +AC_DEFUN([_AX_CHECK_GLU_RESTORE_FLAGS], +[dnl +LIBS="${ax_check_glu_saved_libs}" +CFLAGS="${ax_check_glu_saved_cflags}" +CPPFLAGS="${ax_check_glu_saved_cppflags}" +LDFLAGS="${ax_check_glu_saved_ldflags}" +]) + + +# compile the example program +AC_DEFUN([_AX_CHECK_GLU_COMPILE], +[dnl + AC_LANG_PUSH([C]) + _AX_CHECK_GLU_SAVE_FLAGS() + CFLAGS="${GLU_CFLAGS} ${CFLAGS}" + AC_COMPILE_IFELSE([_AX_CHECK_GLU_PROGRAM], + [ax_check_glu_compile_opengl="yes"], + [ax_check_glu_compile_opengl="no"]) + _AX_CHECK_GLU_RESTORE_FLAGS() + AC_LANG_POP([C]) +]) + +# compile the example program (cache) +AC_DEFUN([_AX_CHECK_GLU_COMPILE_CV], +[dnl + AC_CACHE_CHECK([for compiling a minimal OpenGL Utility (GLU) program],[ax_cv_check_glu_compile_opengl], + [_AX_CHECK_GLU_COMPILE() + ax_cv_check_glu_compile_opengl="${ax_check_glu_compile_opengl}"]) + ax_check_glu_compile_opengl="${ax_cv_check_glu_compile_opengl}" +]) + +# link the example program +AC_DEFUN([_AX_CHECK_GLU_LINK], +[dnl + AC_LANG_PUSH([C]) + _AX_CHECK_GLU_SAVE_FLAGS() + CFLAGS="${GLU_CFLAGS} ${CFLAGS}" + LIBS="${GLU_LIBS} ${LIBS}" + LDFLAGS="${GLU_LDFLAGS} ${LDFLAGS}" + AC_LINK_IFELSE([_AX_CHECK_GLU_PROGRAM], + [ax_check_glu_link_opengl="yes"], + [ax_check_glu_link_opengl="no"]) + _AX_CHECK_GLU_RESTORE_FLAGS() + AC_LANG_POP([C]) +]) + +# link the example program (cache) +AC_DEFUN([_AX_CHECK_GLU_LINK_CV], +[dnl + AC_CACHE_CHECK([for linking a minimal OpenGL Utility (GLU) program],[ax_cv_check_glu_link_opengl], + [_AX_CHECK_GLU_LINK() + ax_cv_check_glu_link_opengl="${ax_check_glu_link_opengl}"]) + ax_check_glu_link_opengl="${ax_cv_check_glu_link_opengl}" +]) + +dnl Check headers manually (default case) +AC_DEFUN([_AX_CHECK_GLU_HEADERS], +[AC_LANG_PUSH([C]) + _AX_CHECK_GLU_SAVE_FLAGS() + CFLAGS="${GLU_CFLAGS} ${CFLAGS}" + # see comment in _AX_CHECK_GL_INCLUDES_DEFAULT + AC_CHECK_HEADERS([windows.h],[],[],[AC_INCLUDES_DEFAULT]) + AC_CHECK_HEADERS([GL/glu.h OpenGL/glu.h], + [ax_check_glu_have_headers="yes";break], + [ax_check_glu_have_headers_headers="no"], + [_AX_CHECK_GLU_INCLUDES_DEFAULT()]) + # do not try darwin specific OpenGl/gl.h + _AX_CHECK_GLU_RESTORE_FLAGS() + AC_LANG_POP([C]) +]) + +# check tesselation callback function signature. +m4_define([_AX_CHECK_GLU_VARARGS_TESSVB_PROGRAM], +[AC_LANG_PROGRAM([[ +# if defined(HAVE_WINDOWS_H) && defined(_WIN32) +# include +# endif +# ifdef HAVE_GL_GLU_H +# include +# elif defined(HAVE_OPENGL_GLU_H) +# include +# else +# error no glu.h +# endif +]], +[[GLvoid (*func)(...); gluTessCallback(0, 0, func)]]) +]) + +# compile the tesselation callback function program +# test with c++ +AC_DEFUN([_AX_CHECK_GLU_COMPILE_VARARGS_TESSVB_PROGRAM], +[AC_REQUIRE([AC_PROG_CXX])dnl + + AC_LANG_PUSH([C++]) + _AX_CHECK_GLU_SAVE_FLAGS() + CFLAGS="${GLU_CFLAGS} ${CFLAGS}" + AC_COMPILE_IFELSE([_AX_CHECK_GLU_VARARGS_TESSVB_PROGRAM], + [ax_check_glu_compile_varargs_tessvb_program="yes"], + [ax_check_glu_compile_varargs_tessvb_program="no"]) + _AX_CHECK_GLU_RESTORE_FLAGS() + AC_LANG_POP([C++]) +]) + + +# +# Some versions of Mac OS X include a broken interpretation of the GLU +# tesselation callback function signature. +# +AC_DEFUN([_AX_CHECK_GLU_VARARGS_TESSVB], +[ +AC_CACHE_CHECK([for varargs OpenGL Utility (GLU) tesselator callback function type], + [ax_cv_varargs_glu_tesscb], + [_AX_CHECK_GLU_COMPILE_VARARGS_TESSVB_PROGRAM + ax_cv_varargs_glu_tesscb="${ax_check_glu_compile_varargs_tessvb_program}"]) +ax_check_glu_compile_varargs_tessvb_program="${ax_cv_varargs_glu_tesscb}" + +AS_IF([test X$ax_cv_varargs_glu_tesscb = Xyes], + [AC_DEFINE([HAVE_VARARGS_GLU_TESSCB], [1], + [Use nonstandard varargs form for the GLU tesselator callback])]) +]) + + +# dnl try to found library (generic case) +# dnl $1 is set to the library to found +AC_DEFUN([_AX_CHECK_GLU_MANUAL_LIBS_GENERIC], +[dnl + ax_check_glu_manual_libs_generic_extra_libs="$1" + AS_IF([test "X$ax_check_glu_manual_libs_generic_extra_libs" = "X"], + [AC_MSG_ERROR([AX_CHECK_GLU_MANUAL_LIBS_GENERIC argument must no be empty])]) + + AC_LANG_PUSH([C]) + _AX_CHECK_GLU_SAVE_FLAGS() + CFLAGS="${GLU_CFLAGS} ${CFLAGS}" + LIBS="${GLU_LIBS} ${LIBS}" + AC_SEARCH_LIBS([gluBeginCurve],[$ax_check_glu_manual_libs_generic_extra_libs], + [ax_check_glu_lib_opengl="yes"], + [ax_check_glu_lib_opengl="no"]) + AS_CASE([$ac_cv_search_gluBeginCurve], + ["none required"],[], + [no],[], + [GLU_LIBS="${ac_cv_search_gluBeginCurve} ${GLU_LIBS}"]) + _AX_CHECK_GLU_RESTORE_FLAGS() + AC_LANG_PUSH([C]) +]) + + +dnl Check library manually: subroutine must set +dnl $ax_check_gl_lib_opengl={yes,no} +AC_DEFUN([_AX_CHECK_GLU_MANUAL_LIBS], +[AC_REQUIRE([AC_CANONICAL_HOST]) + GLU_LIBS="${GLU_LIBS} ${GL_LIBS}" + AS_CASE([${host}], + # try first cygwin version + [*-cygwin*],[_AX_CHECK_GLU_MANUAL_LIBS_GENERIC([GLU glu MesaGLU glu32])], + # try first native + [*-mingw*],[_AX_CHECK_GLU_MANUAL_LIBS_GENERIC([glu32 GLU glu MesaGLU])], + [_AX_CHECK_GLU_MANUAL_LIBS_GENERIC([GLU glu MesaGLU])]) + + AC_CACHE_CHECK([for OpenGL Utility (GLU) libraries],[ax_cv_check_glu_lib_opengl], + [ax_cv_check_glu_lib_opengl="${ax_check_glu_lib_opengl}"]) + ax_check_glu_lib_opengl="${ax_cv_check_glu_lib_opengl}" +]) + + +dnl Manual way to detect GLU +AC_DEFUN([_AX_CHECK_GLU_MANUAL], +[dnl + +# inherit cflags +GLU_CFLAGS="${GLU_CFLAGS} ${GL_CFLAGS}" + +# check headers +_AX_CHECK_GLU_HEADERS + +AS_IF([test "X$ax_check_glu_have_headers" = "Xyes"], + [_AX_CHECK_GLU_MANUAL_LIBS], + [ax_check_glu_lib_opengl="no"]) + +AS_IF([test "X$ax_check_glu_lib_opengl" = "Xyes"], + [_AX_CHECK_GLU_COMPILE_CV()], + [ax_cv_check_glu_compile_opengl="no"]) + +AS_IF([test "X$ax_cv_check_glu_compile_opengl" = "Xyes"], + [_AX_CHECK_GLU_LINK_CV()], + [ax_cv_check_glu_link_opengl="no"]) + +AS_IF([test "X$ax_cv_check_glu_link_opengl" = "Xyes"], + [no_glu="no"], + [no_glu="yes"]) +]) + +# detect using pkgconfig +AC_DEFUN([_AX_CHECK_GLU_PKG_CONFIG], +[ + AC_REQUIRE([PKG_PROG_PKG_CONFIG]) + + PKG_CHECK_MODULES([GLU],[glu],[ax_check_glu_pkg_config=yes],[ax_check_glu_pkg_config=no]) + + AS_IF([test "X$ax_check_glu_pkg_config" = "Xyes"],[ + # check headers + AC_LANG_PUSH([C]) + _AX_CHECK_GLU_SAVE_FLAGS() + CFLAGS="${GLU_CFLAGS} ${CFLAGS}" + AC_CHECK_HEADERS([windows.h],[],[],[AC_INCLUDES_DEFAULT]) + AC_CHECK_HEADERS([GL/glu.h OpenGL/glu.h], + [ax_check_glu_have_headers="yes";break], + [ax_check_glu_have_headers_headers="no"], + [_AX_CHECK_GLU_INCLUDES_DEFAULT()]) + _AX_CHECK_GL_RESTORE_FLAGS() + AC_LANG_POP([C]) + AC_CACHE_CHECK([for OpenGL Utility (GLU) headers],[ax_cv_check_glu_have_headers], + [ax_cv_check_glu_have_headers="${ax_check_glu_have_headers}"]) + + # pkgconfig library are suposed to work ... + AS_IF([test "X$ax_cv_check_glu_have_headers" = "Xno"], + [AC_MSG_ERROR("Pkgconfig detected OpenGL Utility (GLU) library has no headers!")]) + + _AX_CHECK_GLU_COMPILE_CV() + AS_IF([test "X$ax_cv_check_glu_compile_opengl" = "Xno"], + [AC_MSG_ERROR("Pkgconfig detected OpenGL Utility (GLU) library could not be used for compiling minimal program!")]) + + _AX_CHECK_GLU_LINK_CV() + AS_IF([test "X$ax_cv_check_glu_link_opengl" = "Xno"], + [AC_MSG_ERROR("Pkgconfig detected OpenGL Utility (GLU) library could not be used for linking minimal program!")]) + ]) +]) + +# entry point +AC_DEFUN([AX_CHECK_GLU],dnl +[ + AC_REQUIRE([AX_CHECK_GL]) + AC_REQUIRE([PKG_PROG_PKG_CONFIG]) + + # set flags + no_glu="yes" + + AC_MSG_CHECKING([for a working OpenGL Utility (GLU) implementation by pkg-config]) + # try first pkgconfig + AS_IF([test "X${PKG_CONFIG}" = "X"], + [AC_MSG_RESULT([no]) + ax_check_glu_pkg_config=no], + [AC_MSG_RESULT([yes]) + _AX_CHECK_GLU_PKG_CONFIG()]) + + # if no pkg-config or pkg-config fail try manual way + AS_IF([test "X$ax_check_glu_pkg_config" = "Xno"], + [_AX_CHECK_GLU_MANUAL()], + [no_glu=no]) + + # check broken implementation + AS_IF([test "X$no_glu" = "Xno"], + [_AX_CHECK_GLU_VARARGS_TESSVB],[]) + + AC_MSG_CHECKING([for a working OpenGL Utility (GLU) implementation]) + AS_IF([test "X$no_glu" = "Xno"], + [AC_MSG_RESULT([yes]) + AC_MSG_CHECKING([for CFLAGS needed for OpenGL Utility (GLU)]) + AC_MSG_RESULT(["${GLU_CFLAGS}"]) + AC_MSG_CHECKING([for LIBS needed for OpenGL Utility (GLU)]) + AC_MSG_RESULT(["${GLU_LIBS}"]) + AC_MSG_CHECKING([for LDFLAGS needed for OpenGL Utility (GLU)]) + AC_MSG_RESULT(["${GLU_LDFLAGS}"])], + [AC_MSG_RESULT([no]) + GLU_CFLAGS="" + GLU_LIBS="" + GLU_LDFLAGS=""]) + + AC_SUBST([GLU_CFLAGS]) + AC_SUBST([GLU_LIBS]) + AC_SUBST([GLU_LDFLAGS]) + +]) diff --git a/vendor/autoconf-archive b/vendor/autoconf-archive new file mode 160000 index 0000000..1156e13 --- /dev/null +++ b/vendor/autoconf-archive @@ -0,0 +1 @@ +Subproject commit 1156e1362b82616ec34ab037fd334f4bf1c7f7c4 -- 2.30.2