Attachment #13414 for bug #45876

View | Details | Raw Unified | Return to bug 45876
Collapse All | Expand All




++ b/src/hugin1/hugin/ProjectionGridTool.cpp

#ifdef _WIN32
#include "wx/msw/wrapwin.h"
#endif
#include <epoxy/gl.h>
#ifdef __WXMAC__
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#endif
#ifdef __APPLE__

    if (!checked_anisotropic)
    {
        // check if it is supported
        if (epoxy_has_gl_extension("GL_EXT_texture_filter_anisotropic"))
        {
            has_anisotropic = true;
            glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &anisotropy);
++ b/src/hugin1/hugin/TextureManager.cpp


// The OpenGL Extension wrangler libray will find extensions and the latest
// supported OpenGL version on all platforms.
#include <epoxy/gl.h>
#include <wx/platform.h>
#include <wx/display.h>

#ifdef __WXMAC__
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#endif


    if (!checked_anisotropic)
    {
        // check if it is supported
        if (epoxy_has_gl_extension("GL_EXT_texture_filter_anisotropic"))
        {
            has_anisotropic = true;
            glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &anisotropy);
++ b/src/hugin_base/hugin_utils/utils.cpp

#include <libgen.h>       /* dirname */
#endif

#include <epoxy/gl.h>
#ifdef _WIN32
#include <epoxy/wgl.h>
#elif defined __APPLE__
  #include <GLUT/glut.h>
#endif

    {
        return false;
    };
    epoxy_handle_external_wglMakeCurrent();
    return true;
}


    if (context.renderingContext != NULL)
    {
        wglMakeCurrent(NULL, NULL);
        epoxy_handle_external_wglMakeCurrent();
        wglDeleteContext(context.renderingContext);
    }
    if (context.window != NULL && context.dc != NULL)


#else
#if defined HAVE_EGL && HAVE_EGL
#include <epoxy/egl.h>

struct ContextSettings
{

#else
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <epoxy/glx.h>

struct ContextSettings
{

    {
        return false;
    };
    int err = glewInit();
    if (err != GLEW_OK)
    {
        std::cerr << argv[0] << ": an error occurred while setting up the GPU:" << std::endl;
        std::cerr << glewGetErrorString(err) << std::endl;
        std::cerr << argv[0] << ": Switching to CPU calculation." << std::endl;
        DestroyContext();
        return false;
    }

    std::cout << hugin_utils::stripPath(argv[0]) << ": using graphics card: " << glGetString(GL_VENDOR) << " " << glGetString(GL_RENDERER) << std::endl;

    const GLboolean has_arb_fragment_shader = epoxy_has_gl_extension("GL_ARB_fragment_shader");
    const GLboolean has_arb_vertex_shader = epoxy_has_gl_extension("GL_ARB_vertex_shader");
    const GLboolean has_arb_shader_objects = epoxy_has_gl_extension("GL_ARB_shader_objects");
    const GLboolean has_arb_shading_language = epoxy_has_gl_extension("GL_ARB_shading_language_100");
    const GLboolean has_ext_framebuffer = epoxy_has_gl_extension("GL_EXT_framebuffer_object");
    const GLboolean has_arb_texture_rectangle = epoxy_has_gl_extension("GL_ARB_texture_rectangle");
    const GLboolean has_arb_texture_border_clamp = epoxy_has_gl_extension("GL_ARB_texture_border_clamp");
    const GLboolean has_arb_texture_float = epoxy_has_gl_extension("GL_ARB_texture_float");

    if (!(has_arb_fragment_shader && has_arb_vertex_shader && has_arb_shader_objects && has_arb_shading_language && has_ext_framebuffer && has_arb_texture_rectangle && has_arb_texture_border_clamp && has_arb_texture_float)) {
        const char * msg[] = {"false", "true"};
++ b/src/hugin_base/vigra_ext/ImageTransformsGPU.cpp

#include <iostream>
#include <iomanip>

#include <epoxy/gl.h>

#include <string.h>
#ifdef _WIN32

};
#endif
#include <time.h>

#ifdef __WXMAC__
#include <OpenGL/glu.h>
#else
// after windows.h
#include <GL/glu.h>
#endif
#ifdef __APPLE__
  #include <GLUT/glut.h>
#endif

#include <vector>


    const int viewportHeight = std::max<int>(destChunks[0].height(), sourceChunks[0].height());
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0.0, viewportWidth, 0.0, viewportHeight, -1, 1);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glViewport(0, 0, viewportWidth, viewportHeight);
++ b/CMakeLists.txt

  INCLUDE_DIRECTORIES(${GLUT_INCLUDE_DIR})
  SET(OPENGL_GLEW_LIBRARIES ${OPENGL_GLEW_LIBRARIES} ${GLUT_LIBRARIES})
ENDIF()
PKG_SEARCH_MODULE(EPOXY epoxy REQUIRED)
INCLUDE_DIRECTORIES(${EPOXY_INCLUDE_DIR})
SET(OPENGL_GLEW_LIBRARIES ${OPENGL_GLEW_LIBRARIES} ${EPOXY_LIBRARIES})
IF(NOT HUGIN_SHARED OR NOT WIN32)
  ADD_DEFINITIONS(-DGLEW_STATIC)
ENDIF()
++ b/src/hugin1/hugin/GLPreviewFrame.cpp

#include <iostream>

#include "hugin_config.h"

#include <GL/glew.h>

#include "panoinc_WX.h"
#include "panoinc.h"
++ b/src/hugin1/hugin/GLViewer.cpp


#include "panoinc.h"
#include "hugin_config.h"
#include <epoxy/gl.h>
#include <base_wx/platform.h>
#include <wx/settings.h>
#include <wx/dcclient.h>

#include "GLPreviewFrame.h"
#include "hugin/huginApp.h"

bool GLViewer::initialised_glew=false;
ViewState * GLViewer::m_view_state = NULL;
size_t GLViewer::m_view_state_observer = 0;


        // It appears we are setting up for the first time.
        started_creation = true;
        
        if (!initialised_glew)
        {
            // initialise the glew library, if not done it before.
            GLenum error_state = glewInit();
            initialised_glew = true;
            if (error_state != GLEW_OK)
            {
                // glewInit failed
                started_creation=false;
                DEBUG_ERROR("Error initialising GLEW: "
                        << glewGetErrorString(error_state) << ".");
                frame->Close();
                wxMessageBox(_("Error initializing GLEW\nFast preview window can not be opened."),_("Error"), wxOK | wxICON_ERROR);
                return;
            }
        }
        // check the openGL capabilities.
        if (epoxy_gl_version() < 11 && !epoxy_has_gl_extension("GL_ARB_multitexture"))
        {
            started_creation=false;
            wxConfigBase::Get()->Write(wxT("DisableOpenGL"), 1l);
++ b/src/hugin1/hugin/GLViewer.h

    virtual void setUp() = 0;

    bool started_creation, redrawing, m_toolsInitialized;
    static bool initialised_glew;
    vigra::Diff2D offset;
    double m_scale = 1.0;
    GLPreviewFrame *frame;
++ b/src/hugin1/hugin/MeshManager.cpp

#include <wx/wx.h>
#include <wx/platform.h>

#include <epoxy/gl.h>

#ifdef __WXMAC__
#include <OpenGL/gl.h>
#else
#ifdef __WXMSW__
#include <vigra/windows.h>
#endif
#include <GL/gl.h>
#endif

#include "panoinc.h"
++ b/src/hugin1/hugin/OverviewOutlinesTool.cpp

#ifdef _WIN32
#include "wx/msw/wrapwin.h"
#endif
#include <epoxy/gl.h>
#ifdef __WXMAC__
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#endif
#ifdef __APPLE__
++ b/src/hugin1/hugin/PanosphereSphereTool.cpp

#ifdef _WIN32
#include "wx/msw/wrapwin.h"
#endif
#include <epoxy/gl.h>
#ifdef __WXMAC__
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#endif
#ifdef __APPLE__
++ b/src/hugin1/hugin/PreviewDifferenceTool.cpp

#endif
#include "PreviewDifferenceTool.h"
#include "hugin_config.h"
#include <epoxy/gl.h>
#include <wx/platform.h>
#ifdef __WXMAC__
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif

// This is the number of times to double the result of the difference. It should
// be between 0 and 7. Note that with  values > 0 no extra colours are used

/** call this function only after OpenGL context was created */
bool PreviewDifferenceTool::CheckOpenGLCanDifference()
{
    if(epoxy_has_gl_extension("GL_ARB_imaging"))
        return true;
    if((glBlendEquation!=NULL) && (epoxy_has_gl_extension("GL_EXT_blend_subtract")))
        return true;
    return false;
}
++ b/src/hugin1/hugin/PreviewIdentifyTool.cpp


#include <wx/platform.h>

#include <epoxy/gl.h>
#include <GL/glew.h>

#ifdef __WXMAC__
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#endif

Return to bug 45876

Line Link Here

(-)file_not_specified_in_diff (-95 / +56 lines)
0	-- a/src/hugin1/hugin/ProjectionGridTool.cpp	0	++ b/src/hugin1/hugin/ProjectionGridTool.cpp
Lines 24-35 Link Here
24	#ifdef _WIN32	24	#ifdef _WIN32
25	#include "wx/msw/wrapwin.h"	25	#include "wx/msw/wrapwin.h"
26	#endif	26	#endif
27	#include <GL/glew.h>	27	#include <epoxy/gl.h>
28	#ifdef __WXMAC__	28	#ifdef __WXMAC__
29	#include <OpenGL/gl.h>
30	#include <OpenGL/glu.h>	29	#include <OpenGL/glu.h>
31	#else	30	#else
32	#include <GL/gl.h>
33	#include <GL/glu.h>	31	#include <GL/glu.h>
34	#endif	32	#endif
35	#ifdef __APPLE__	33	#ifdef __APPLE__
Lines 323-329 Link Here
323	if (!checked_anisotropic)	321	if (!checked_anisotropic)
324	{	322	{
325	// check if it is supported	323	// check if it is supported
326	if (GLEW_EXT_texture_filter_anisotropic)	324	if (epoxy_has_gl_extension("GL_EXT_texture_filter_anisotropic"))
327	{	325	{
328	has_anisotropic = true;	326	has_anisotropic = true;
329	glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &anisotropy);	327	glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &anisotropy);
330	-- a/src/hugin1/hugin/TextureManager.cpp	328	++ b/src/hugin1/hugin/TextureManager.cpp
Lines 48-62 Link Here
48		48
49	// The OpenGL Extension wrangler libray will find extensions and the latest	49	// The OpenGL Extension wrangler libray will find extensions and the latest
50	// supported OpenGL version on all platforms.	50	// supported OpenGL version on all platforms.
51	#include <GL/glew.h>	51	#include <epoxy/gl.h>
52	#include <wx/platform.h>	52	#include <wx/platform.h>
53	#include <wx/display.h>	53	#include <wx/display.h>
54		54
55	#ifdef __WXMAC__	55	#ifdef __WXMAC__
56	#include <OpenGL/gl.h>
57	#include <OpenGL/glu.h>	56	#include <OpenGL/glu.h>
58	#else	57	#else
59	#include <GL/gl.h>
60	#include <GL/glu.h>	58	#include <GL/glu.h>
61	#endif	59	#endif
62		60
Lines 628-634 Link Here
628	if (!checked_anisotropic)	626	if (!checked_anisotropic)
629	{	627	{
630	// check if it is supported	628	// check if it is supported
631	if (GLEW_EXT_texture_filter_anisotropic)	629	if (epoxy_has_gl_extension("GL_EXT_texture_filter_anisotropic"))
632	{	630	{
633	has_anisotropic = true;	631	has_anisotropic = true;
634	glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &anisotropy);	632	glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &anisotropy);
635	-- a/src/hugin_base/hugin_utils/utils.cpp	633	++ b/src/hugin_base/hugin_utils/utils.cpp
Lines 57-65 Link Here
57	#include <libgen.h> /* dirname */	57	#include <libgen.h> /* dirname */
58	#endif	58	#endif
59		59
60	#include <GL/glew.h>	60	#include <epoxy/gl.h>
61	#ifdef _WIN32	61	#ifdef _WIN32
62	#include <GL/wglew.h>	62	#include <epoxy/wgl.h>
63	#elif defined __APPLE__	63	#elif defined __APPLE__
64	#include <GLUT/glut.h>	64	#include <GLUT/glut.h>
65	#endif	65	#endif
Lines 584-589 Link Here
584	{	584	{
585	return false;	585	return false;
586	};	586	};
		587	epoxy_handle_external_wglMakeCurrent();
587	return true;	588	return true;
588	}	589	}
589		590
Lines 592-597 Link Here
592	if (context.renderingContext != NULL)	593	if (context.renderingContext != NULL)
593	{	594	{
594	wglMakeCurrent(NULL, NULL);	595	wglMakeCurrent(NULL, NULL);
		596	epoxy_handle_external_wglMakeCurrent();
595	wglDeleteContext(context.renderingContext);	597	wglDeleteContext(context.renderingContext);
596	}	598	}
597	if (context.window != NULL && context.dc != NULL)	599	if (context.window != NULL && context.dc != NULL)
Lines 628-634 Link Here
628		630
629	#else	631	#else
630	#if defined HAVE_EGL && HAVE_EGL	632	#if defined HAVE_EGL && HAVE_EGL
631	#include <EGL/egl.h>	633	#include <epoxy/egl.h>
632		634
633	struct ContextSettings	635	struct ContextSettings
634	{	636	{
Lines 714-720 Link Here
714	#else	716	#else
715	#include <X11/Xlib.h>	717	#include <X11/Xlib.h>
716	#include <X11/Xutil.h>	718	#include <X11/Xutil.h>
717	#include <GL/glx.h>	719	#include <epoxy/glx.h>
718		720
719	struct ContextSettings	721	struct ContextSettings
720	{	722	{
Lines 811-836 Link Here
811	{	813	{
812	return false;	814	return false;
813	};	815	};
814	int err = glewInit();
815	if (err != GLEW_OK)
816	{
817	std::cerr << argv[0] << ": an error occurred while setting up the GPU:" << std::endl;
818	std::cerr << glewGetErrorString(err) << std::endl;
819	std::cerr << argv[0] << ": Switching to CPU calculation." << std::endl;
820	DestroyContext();
821	return false;
822	}
823		816
824	std::cout << hugin_utils::stripPath(argv[0]) << ": using graphics card: " << glGetString(GL_VENDOR) << " " << glGetString(GL_RENDERER) << std::endl;	817	std::cout << hugin_utils::stripPath(argv[0]) << ": using graphics card: " << glGetString(GL_VENDOR) << " " << glGetString(GL_RENDERER) << std::endl;
825		818
826	const GLboolean has_arb_fragment_shader = glewGetExtension("GL_ARB_fragment_shader");	819	const GLboolean has_arb_fragment_shader = epoxy_has_gl_extension("GL_ARB_fragment_shader");
827	const GLboolean has_arb_vertex_shader = glewGetExtension("GL_ARB_vertex_shader");	820	const GLboolean has_arb_vertex_shader = epoxy_has_gl_extension("GL_ARB_vertex_shader");
828	const GLboolean has_arb_shader_objects = glewGetExtension("GL_ARB_shader_objects");	821	const GLboolean has_arb_shader_objects = epoxy_has_gl_extension("GL_ARB_shader_objects");
829	const GLboolean has_arb_shading_language = glewGetExtension("GL_ARB_shading_language_100");	822	const GLboolean has_arb_shading_language = epoxy_has_gl_extension("GL_ARB_shading_language_100");
830	const GLboolean has_ext_framebuffer = glewGetExtension("GL_EXT_framebuffer_object");	823	const GLboolean has_ext_framebuffer = epoxy_has_gl_extension("GL_EXT_framebuffer_object");
831	const GLboolean has_arb_texture_rectangle = glewGetExtension("GL_ARB_texture_rectangle");	824	const GLboolean has_arb_texture_rectangle = epoxy_has_gl_extension("GL_ARB_texture_rectangle");
832	const GLboolean has_arb_texture_border_clamp = glewGetExtension("GL_ARB_texture_border_clamp");	825	const GLboolean has_arb_texture_border_clamp = epoxy_has_gl_extension("GL_ARB_texture_border_clamp");
833	const GLboolean has_arb_texture_float = glewGetExtension("GL_ARB_texture_float");	826	const GLboolean has_arb_texture_float = epoxy_has_gl_extension("GL_ARB_texture_float");
834		827
835	if (!(has_arb_fragment_shader && has_arb_vertex_shader && has_arb_shader_objects && has_arb_shading_language && has_ext_framebuffer && has_arb_texture_rectangle && has_arb_texture_border_clamp && has_arb_texture_float)) {	828	if (!(has_arb_fragment_shader && has_arb_vertex_shader && has_arb_shader_objects && has_arb_shading_language && has_ext_framebuffer && has_arb_texture_rectangle && has_arb_texture_border_clamp && has_arb_texture_float)) {
836	const char * msg[] = {"false", "true"};	829	const char * msg[] = {"false", "true"};
837	-- a/src/hugin_base/vigra_ext/ImageTransformsGPU.cpp	830	++ b/src/hugin_base/vigra_ext/ImageTransformsGPU.cpp
Lines 26-32 Link Here
26	#include <iostream>	26	#include <iostream>
27	#include <iomanip>	27	#include <iomanip>
28		28
29	#include <GL/glew.h>	29	#include <epoxy/gl.h>
30		30
31	#include <string.h>	31	#include <string.h>
32	#ifdef _WIN32	32	#ifdef _WIN32
Lines 54-59 Link Here
54	};	54	};
55	#endif	55	#endif
56	#include <time.h>	56	#include <time.h>
		57
		58	#ifdef __WXMAC__
		59	#include <OpenGL/glu.h>
		60	#else
		61	// after windows.h
		62	#include <GL/glu.h>
		63	#endif
		64	#ifdef __APPLE__
		65	#include <GLUT/glut.h>
		66	#endif
57		67
58	#include <vector>	68	#include <vector>
59		69
Lines 798-804 Link Here
798	const int viewportHeight = std::max<int>(destChunks[0].height(), sourceChunks[0].height());	808	const int viewportHeight = std::max<int>(destChunks[0].height(), sourceChunks[0].height());
799	glMatrixMode(GL_PROJECTION);	809	glMatrixMode(GL_PROJECTION);
800	glLoadIdentity();	810	glLoadIdentity();
801	gluOrtho2D(0.0, viewportWidth, 0.0, viewportHeight);	811	glOrtho(0.0, viewportWidth, 0.0, viewportHeight, -1, 1);
802	glMatrixMode(GL_MODELVIEW);	812	glMatrixMode(GL_MODELVIEW);
803	glLoadIdentity();	813	glLoadIdentity();
804	glViewport(0, 0, viewportWidth, viewportHeight);	814	glViewport(0, 0, viewportWidth, viewportHeight);
805	-- a/CMakeLists.txt	815	++ b/CMakeLists.txt
Lines 255-263 Link Here
255	INCLUDE_DIRECTORIES(${GLUT_INCLUDE_DIR})	255	INCLUDE_DIRECTORIES(${GLUT_INCLUDE_DIR})
256	SET(OPENGL_GLEW_LIBRARIES ${OPENGL_GLEW_LIBRARIES} ${GLUT_LIBRARIES})	256	SET(OPENGL_GLEW_LIBRARIES ${OPENGL_GLEW_LIBRARIES} ${GLUT_LIBRARIES})
257	ENDIF()	257	ENDIF()
258	FIND_PACKAGE(GLEW REQUIRED)	258	PKG_SEARCH_MODULE(EPOXY epoxy REQUIRED)
259	INCLUDE_DIRECTORIES(${GLEW_INCLUDE_DIR})	259	INCLUDE_DIRECTORIES(${EPOXY_INCLUDE_DIR})
260	SET(OPENGL_GLEW_LIBRARIES ${OPENGL_GLEW_LIBRARIES} ${GLEW_LIBRARIES})	260	SET(OPENGL_GLEW_LIBRARIES ${OPENGL_GLEW_LIBRARIES} ${EPOXY_LIBRARIES})
261	IF(NOT HUGIN_SHARED OR NOT WIN32)	261	IF(NOT HUGIN_SHARED OR NOT WIN32)
262	ADD_DEFINITIONS(-DGLEW_STATIC)	262	ADD_DEFINITIONS(-DGLEW_STATIC)
263	ENDIF()	263	ENDIF()
264	-- a/src/hugin1/hugin/GLPreviewFrame.cpp	264	++ b/src/hugin1/hugin/GLPreviewFrame.cpp
Lines 28-35 Link Here
28	#include <iostream>	28	#include <iostream>
29		29
30	#include "hugin_config.h"	30	#include "hugin_config.h"
31
32	#include <GL/glew.h>
33		31
34	#include "panoinc_WX.h"	32	#include "panoinc_WX.h"
35	#include "panoinc.h"	33	#include "panoinc.h"
36	-- a/src/hugin1/hugin/GLViewer.cpp	34	++ b/src/hugin1/hugin/GLViewer.cpp
Lines 25-31 Link Here
25		25
26	#include "panoinc.h"	26	#include "panoinc.h"
27	#include "hugin_config.h"	27	#include "hugin_config.h"
28	#include <GL/glew.h>	28	#include <epoxy/gl.h>
29	#include <base_wx/platform.h>	29	#include <base_wx/platform.h>
30	#include <wx/settings.h>	30	#include <wx/settings.h>
31	#include <wx/dcclient.h>	31	#include <wx/dcclient.h>
Lines 39-45 Link Here
39	#include "GLPreviewFrame.h"	39	#include "GLPreviewFrame.h"
40	#include "hugin/huginApp.h"	40	#include "hugin/huginApp.h"
41		41
42	bool GLViewer::initialised_glew=false;
43	ViewState * GLViewer::m_view_state = NULL;	42	ViewState * GLViewer::m_view_state = NULL;
44	size_t GLViewer::m_view_state_observer = 0;	43	size_t GLViewer::m_view_state_observer = 0;
45		44
Lines 121-144 Link Here
121	// It appears we are setting up for the first time.	120	// It appears we are setting up for the first time.
122	started_creation = true;	121	started_creation = true;
123		122
124	if (!initialised_glew)
125	{
126	// initialise the glew library, if not done it before.
127	GLenum error_state = glewInit();
128	initialised_glew = true;
129	if (error_state != GLEW_OK)
130	{
131	// glewInit failed
132	started_creation=false;
133	DEBUG_ERROR("Error initialising GLEW: "
134	<< glewGetErrorString(error_state) << ".");
135	frame->Close();
136	wxMessageBox(_("Error initializing GLEW\nFast preview window can not be opened."),_("Error"), wxOK \| wxICON_ERROR);
137	return;
138	}
139	}
140	// check the openGL capabilities.	123	// check the openGL capabilities.
141	if (!(GLEW_VERSION_1_1 && GLEW_ARB_multitexture))	124	if (epoxy_gl_version() < 11 && !epoxy_has_gl_extension("GL_ARB_multitexture"))
142	{	125	{
143	started_creation=false;	126	started_creation=false;
144	wxConfigBase::Get()->Write(wxT("DisableOpenGL"), 1l);	127	wxConfigBase::Get()->Write(wxT("DisableOpenGL"), 1l);
145	-- a/src/hugin1/hugin/GLViewer.h	128	++ b/src/hugin1/hugin/GLViewer.h
Lines 99-105 Link Here
99	virtual void setUp() = 0;	99	virtual void setUp() = 0;
100		100
101	bool started_creation, redrawing, m_toolsInitialized;	101	bool started_creation, redrawing, m_toolsInitialized;
102	static bool initialised_glew;
103	vigra::Diff2D offset;	102	vigra::Diff2D offset;
104	double m_scale = 1.0;	103	double m_scale = 1.0;
105	GLPreviewFrame *frame;	104	GLPreviewFrame *frame;
106	-- a/src/hugin1/hugin/MeshManager.cpp	105	++ b/src/hugin1/hugin/MeshManager.cpp
Lines 23-37 Link Here
23	#include <wx/wx.h>	23	#include <wx/wx.h>
24	#include <wx/platform.h>	24	#include <wx/platform.h>
25		25
26	#include <GL/glew.h>	26	#include <epoxy/gl.h>
27		27
28	#ifdef __WXMAC__
29	#include <OpenGL/gl.h>
30	#else
31	#ifdef __WXMSW__	28	#ifdef __WXMSW__
32	#include <vigra/windows.h>	29	#include <vigra/windows.h>
33	#endif
34	#include <GL/gl.h>
35	#endif	30	#endif
36		31
37	#include "panoinc.h"	32	#include "panoinc.h"
38	-- a/src/hugin1/hugin/OverviewOutlinesTool.cpp	33	++ b/src/hugin1/hugin/OverviewOutlinesTool.cpp
Lines 22-33 Link Here
22	#ifdef _WIN32	22	#ifdef _WIN32
23	#include "wx/msw/wrapwin.h"	23	#include "wx/msw/wrapwin.h"
24	#endif	24	#endif
25	#include <GL/glew.h>	25	#include <epoxy/gl.h>
26	#ifdef __WXMAC__	26	#ifdef __WXMAC__
27	#include <OpenGL/gl.h>
28	#include <OpenGL/glu.h>	27	#include <OpenGL/glu.h>
29	#else	28	#else
30	#include <GL/gl.h>
31	#include <GL/glu.h>	29	#include <GL/glu.h>
32	#endif	30	#endif
33	#ifdef __APPLE__	31	#ifdef __APPLE__
34	-- a/src/hugin1/hugin/PanosphereSphereTool.cpp	32	++ b/src/hugin1/hugin/PanosphereSphereTool.cpp
Lines 24-35 Link Here
24	#ifdef _WIN32	24	#ifdef _WIN32
25	#include "wx/msw/wrapwin.h"	25	#include "wx/msw/wrapwin.h"
26	#endif	26	#endif
27	#include <GL/glew.h>	27	#include <epoxy/gl.h>
28	#ifdef __WXMAC__	28	#ifdef __WXMAC__
29	#include <OpenGL/gl.h>
30	#include <OpenGL/glu.h>	29	#include <OpenGL/glu.h>
31	#else	30	#else
32	#include <GL/gl.h>
33	#include <GL/glu.h>	31	#include <GL/glu.h>
34	#endif	32	#endif
35	#ifdef __APPLE__	33	#ifdef __APPLE__
36	-- a/src/hugin1/hugin/PreviewDifferenceTool.cpp	34	++ b/src/hugin1/hugin/PreviewDifferenceTool.cpp
Lines 24-36 Link Here
24	#endif	24	#endif
25	#include "PreviewDifferenceTool.h"	25	#include "PreviewDifferenceTool.h"
26	#include "hugin_config.h"	26	#include "hugin_config.h"
27	#include <GL/glew.h>	27	#include <epoxy/gl.h>
28	#include <wx/platform.h>	28	#include <wx/platform.h>
29	#ifdef __WXMAC__
30	#include <OpenGL/gl.h>
31	#else
32	#include <GL/gl.h>
33	#endif
34		29
35	// This is the number of times to double the result of the difference. It should	30	// This is the number of times to double the result of the difference. It should
36	// be between 0 and 7. Note that with values > 0 no extra colours are used	31	// be between 0 and 7. Note that with values > 0 no extra colours are used
Lines 46-54 Link Here
46	/** call this function only after OpenGL context was created */	41	/** call this function only after OpenGL context was created */
47	bool PreviewDifferenceTool::CheckOpenGLCanDifference()	42	bool PreviewDifferenceTool::CheckOpenGLCanDifference()
48	{	43	{
49	if(GLEW_ARB_imaging)	44	if(epoxy_has_gl_extension("GL_ARB_imaging"))
50	return true;	45	return true;
51	if((glBlendEquation!=NULL) && (GLEW_EXT_blend_subtract))	46	if((glBlendEquation!=NULL) && (epoxy_has_gl_extension("GL_EXT_blend_subtract")))
52	return true;	47	return true;
53	return false;	48	return false;
54	}	49	}
55	-- a/src/hugin1/hugin/PreviewIdentifyTool.cpp	50	++ b/src/hugin1/hugin/PreviewIdentifyTool.cpp
Lines 31-44 Link Here
31		31
32	#include <wx/platform.h>	32	#include <wx/platform.h>
33		33
34	//multitexture feature requires glew on some systems	34	#include <epoxy/gl.h>
35	#include <GL/glew.h>
36
37	#ifdef __WXMAC__	35	#ifdef __WXMAC__
38	#include <OpenGL/gl.h>
39	#include <OpenGL/glu.h>	36	#include <OpenGL/glu.h>
40	#else	37	#else
41	#include <GL/gl.h>
42	#include <GL/glu.h>	38	#include <GL/glu.h>
43	#endif	39	#endif