Navigation

← Previous Changeset
Next Changeset →

Changeset 19883

Timestamp:

03/25/07 17:53:46 (2 years ago)

Author:

patrick

Message:

Fixed coding standard violations. No functional changes.

Files:

juggler/trunk/modules/vrjuggler/vrj/Draw/OGL/GlExtensionLoaderWin32.cpp (modified) (4 diffs)
juggler/trunk/modules/vrjuggler/vrj/Draw/OGL/GlExtensionLoaderWin32.h (modified) (3 diffs)
juggler/trunk/modules/vrjuggler/vrj/Draw/OGL/GlxExtensionLoader.cpp (modified) (2 diffs)
juggler/trunk/modules/vrjuggler/vrj/Draw/OGL/GlxExtensionLoader.h (modified) (3 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

juggler/trunk/modules/vrjuggler/vrj/Draw/OGL/GlExtensionLoaderWin32.cpp

r19729	r19883
36	36	namespace vrj
37	37	{
38		// NVIDIA swap control
39		typedef BOOL (GLAPI * PFNWGLJOINSWAPGROUPNVPROC) (HDC hdc,
40		GLuint group);
41
42		typedef BOOL (GLAPI * PFNWGLBINDSWAPBARRIERNVPROC) (GLuint group,
43		GLuint barrier);
44
45		typedef BOOL (GLAPI * PFNWGLQUERYSWAPGROUPNVPROC) (HDC hdc,
46		GLuint *group,
47		GLuint *barrier);
48
49		typedef BOOL (GLAPI * PFNWGLQUERYMAXSWAPGROUPSNVPROC) (HDC hdc,
50		/int screen,/
51		GLuint *maxGroups,
52		GLuint *maxBarriers);
53
54		typedef BOOL (GLAPI * PFNWGLQUERYFRAMECOUNTNVPROC) (HDC hdc,
55		/int screen,/
56		GLuint *count);
57
58		typedef BOOL (GLAPI * PFNWGLRESETFRAMECOUNTNVPROC) (HDC hdc/, int screen/);
	38	// NVIDIA swap control
	39	typedef BOOL (GLAPI * PFNWGLJOINSWAPGROUPNVPROC) (HDC hdc, GLuint group);
	40
	41	typedef BOOL (GLAPI * PFNWGLBINDSWAPBARRIERNVPROC) (GLuint group,
	42	GLuint barrier);
	43
	44	typedef BOOL (GLAPI * PFNWGLQUERYSWAPGROUPNVPROC) (HDC hdc, GLuint* group,
	45	GLuint* barrier);
	46
	47	typedef BOOL (GLAPI * PFNWGLQUERYMAXSWAPGROUPSNVPROC) (HDC hdc,
	48	/int screen,/
	49	GLuint* maxGroups,
	50	GLuint* maxBarriers);
	51
	52	typedef BOOL (GLAPI * PFNWGLQUERYFRAMECOUNTNVPROC) (HDC hdc,
	53	/int screen,/
	54	GLuint* count);
	55
	56	typedef BOOL (GLAPI * PFNWGLRESETFRAMECOUNTNVPROC) (HDC hdc /, int screen/);
59	57
60	58
…	…
62	60	{
63	61	WglFuncs()
	62	: wglJoinSwapGroupNV(NULL)
	63	, wglBindSwapBarrierNV(NULL)
	64	, wglQuerySwapGroupNV(NULL)
	65	, wglQueryMaxSwapGroupsNV(NULL)
	66	, wglQueryFrameCountNV(NULL)
	67	, wglResetFrameCountNV(NULL)
64	68	{
65		wglJoinSwapGroupNV = NULL;
66		wglBindSwapBarrierNV = NULL;
67		wglQuerySwapGroupNV = NULL;
68		wglQueryMaxSwapGroupsNV = NULL;
69		wglQueryFrameCountNV = NULL;
70		wglResetFrameCountNV = NULL;
	69	/* Do nothing. */ ;
71	70	}
72	71
…	…
104	103	BOOL GlExtensionLoaderWin32::wglJoinSwapGroupNV(HDC hdc, GLuint group)
105	104	{
106		vprASSERT(mWglFuncs->wglJoinSwapGroupNV != NULL && "Attemped to call unsupported extension.");
	105	vprASSERT(mWglFuncs->wglJoinSwapGroupNV != NULL &&
	106	"Attemped to call unsupported extension.");
107	107	return mWglFuncs->wglJoinSwapGroupNV(hdc, group);
108	108	}
…	…
110	110	BOOL GlExtensionLoaderWin32::wglBindSwapBarrierNV(GLuint group, GLuint barrier)
111	111	{
112		vprASSERT(mWglFuncs->wglBindSwapBarrierNV != NULL && "Attemped to call unsupported extension.");
	112	vprASSERT(mWglFuncs->wglBindSwapBarrierNV != NULL &&
	113	"Attemped to call unsupported extension.");
113	114	return mWglFuncs->wglBindSwapBarrierNV(group, barrier);
114	115	}
115	116
116		BOOL GlExtensionLoaderWin32::wglQuerySwapGroupNV(HDC hdc, GLuint group, GLuint barrier)
	117	BOOL GlExtensionLoaderWin32::wglQuerySwapGroupNV(HDC hdc, GLuint* group,
	118	GLuint* barrier)
117	119	{
118		vprASSERT(mWglFuncs->wglQuerySwapGroupNV != NULL && "Attemped to call unsupported extension.");
	120	vprASSERT(mWglFuncs->wglQuerySwapGroupNV != NULL &&
	121	"Attemped to call unsupported extension.");
119	122	return mWglFuncs->wglQuerySwapGroupNV(hdc, group, barrier);
120	123	}
121	124
122		BOOL GlExtensionLoaderWin32::wglQueryMaxSwapGroupsNV(HDC hdc, GLuint maxGroups, GLuint maxBarriers)
	125	BOOL GlExtensionLoaderWin32::wglQueryMaxSwapGroupsNV(HDC hdc,
	126	GLuint* maxGroups,
	127	GLuint* maxBarriers)
123	128	{
124		vprASSERT(mWglFuncs->wglQueryMaxSwapGroupsNV != NULL && "Attemped to call unsupported extension.");
	129	vprASSERT(mWglFuncs->wglQueryMaxSwapGroupsNV != NULL &&
	130	"Attemped to call unsupported extension.");
125	131	return mWglFuncs->wglQueryMaxSwapGroupsNV(hdc, maxGroups, maxBarriers);
126	132	}
127	133
128		BOOL GlExtensionLoaderWin32::wglQueryFrameCountNV(HDC hdc, /int screen,/ GLuint *count)
	134	BOOL GlExtensionLoaderWin32::wglQueryFrameCountNV(HDC hdc, /int screen,/
	135	GLuint* count)
129	136	{
130		vprASSERT(mWglFuncs->wglQueryFrameCountNV != NULL && "Attemped to call unsupported extension.");
	137	vprASSERT(mWglFuncs->wglQueryFrameCountNV != NULL &&
	138	"Attemped to call unsupported extension.");
131	139	return mWglFuncs->wglQueryFrameCountNV(hdc, /screen,/ count);
132	140	}
133	141
134		BOOL GlExtensionLoaderWin32::wglResetFrameCountNV(HDC hdc/, int screen/)
	142	BOOL GlExtensionLoaderWin32::wglResetFrameCountNV(HDC hdc /, int screen/)
135	143	{
136		vprASSERT(mWglFuncs->wglResetFrameCountNV != NULL && "Attemped to call unsupported extension.");
137		return mWglFuncs->wglResetFrameCountNV(hdc/, screen/);
	144	vprASSERT(mWglFuncs->wglResetFrameCountNV != NULL &&
	145	"Attemped to call unsupported extension.");
	146	return mWglFuncs->wglResetFrameCountNV(hdc /, screen/);
138	147	}
139	148

juggler/trunk/modules/vrjuggler/vrj/Draw/OGL/GlExtensionLoaderWin32.h

r19729	r19883
28	28	#define VRJ_WGL_EXTENSION_LOADER_H_
29	29
30		#include <vrj/Draw/OGL/GlExtensionLoader.h>
	30	#include <vrj/Draw/OGL/Config.h>
	31
31	32	#include <boost/shared_ptr.hpp>
32	33
33		~~#include <windows.h>~~
34	34	#include <GL/gl.h>
	35
	36	#include <vrj/Draw/OGL/GlExtensionLoader.h>
	37
35	38
36	39	namespace vrj
…	…
58	61	BOOL wglBindSwapBarrierNV(GLuint group, GLuint barrier);
59	62
60		BOOL wglQuerySwapGroupNV(HDC hdc, GLuint ~~group, GLuint ~~barrier);
	63	BOOL wglQuerySwapGroupNV(HDC hdc, GLuint* group, GLuint* barrier);
61	64
62		BOOL wglQueryMaxSwapGroupsNV(HDC hdc, GLuint maxGroups, GLuint maxBarriers);
	65	BOOL wglQueryMaxSwapGroupsNV(HDC hdc, GLuint* maxGroups,
	66	GLuint* maxBarriers);
63	67
64		BOOL wglQueryFrameCountNV(HDC hdc, /int screen,/ GLuint *count);
	68	BOOL wglQueryFrameCountNV(HDC hdc, /int screen,/ GLuint* count);
65	69
66		BOOL wglResetFrameCountNV(HDC hdc/, int screen/);
	70	BOOL wglResetFrameCountNV(HDC hdc /, int screen/);
67	71	//@}
68	72
…	…
75	79	} // namespace vrj
76	80
	81
77	82	#endif
78

juggler/trunk/modules/vrjuggler/vrj/Draw/OGL/GlxExtensionLoader.cpp

r19729	r19883
25	25	************* <auto-copyright.pl END do not edit this line> *************/
26	26
27		#include <vrj/Draw/OGL/GlxExtensionLoader.h>
28		#include <vpr/Util/Debug.h>
29		#include <vpr/Util/Assert.h>
	27	#include <vrj/Draw/OGL/Config.h>
	28
30	29	#include <GL/glx.h>
31	30	#include <GL/glxext.h>
32	31
	32	#include <vpr/Util/Debug.h>
	33	#include <vpr/Util/Assert.h>
	34
	35	#include <vrj/Draw/OGL/GlxExtensionLoader.h>
	36
	37
33	38	namespace vrj
34	39	{
35		// NVIDIA swap control
36		typedef Bool ( * PFNGLXJOINSWAPGROUPNVPROC) (::Display *dpy,
37		GLXDrawable drawable,
38		GLuint group);
39
40		typedef Bool ( * PFNGLXBINDSWAPBARRIERNVPROC) (::Display *dpy,
41		GLuint group,
42		GLuint barrier);
43
44		typedef Bool ( * PFNGLXQUERYSWAPGROUPNVPROC) (::Display *dpy,
45		GLXDrawable drawable,
46		GLuint *group,
47		GLuint *barrier);
48
49		typedef Bool ( * PFNGLXQUERYMAXSWAPGROUPSNVPROC) (::Display *dpy,
50		int screen,
51		GLuint *maxGroups,
52		GLuint *maxBarriers);
53
54		typedef Bool ( * PFNGLXQUERYFRAMECOUNTNVPROC) (::Display *dpy,
55		int screen,
56		GLuint *count);
57
58		typedef Bool ( * PFNGLXRESETFRAMECOUNTNVPROC) (::Display *dpy, int screen);
	40
	41	// NVIDIA swap control
	42	typedef Bool (* PFNGLXJOINSWAPGROUPNVPROC) (::Display*, GLXDrawable,
	43	GLuint);
	44
	45	typedef Bool (* PFNGLXBINDSWAPBARRIERNVPROC) (::Display*, GLuint, GLuint);
	46
	47	typedef Bool (* PFNGLXQUERYSWAPGROUPNVPROC) (::Display*, GLXDrawable,
	48	GLuint, GLuint);
	49
	50	typedef Bool (* PFNGLXQUERYMAXSWAPGROUPSNVPROC) (::Display, int, GLuint,
	51	GLuint*);
	52
	53	typedef Bool (* PFNGLXQUERYFRAMECOUNTNVPROC) (::Display, int, GLuint);
	54
	55	typedef Bool (* PFNGLXRESETFRAMECOUNTNVPROC) (::Display*, int);
59	56
60	57	struct GlxExtensionLoader::GlxFuncs
61	58	{
62	59	GlxFuncs()
	60	: glXJoinSwapGroupNV(NULL)
	61	, glXBindSwapBarrierNV(NULL)
	62	, glXQuerySwapGroupNV(NULL)
	63	, glXQueryMaxSwapGroupsNV(NULL)
	64	, glXQueryFrameCountNV(NULL)
	65	, glXResetFrameCountNV(NULL)
63	66	{
64		glXJoinSwapGroupNV = NULL;
65		glXBindSwapBarrierNV = NULL;
66		glXQuerySwapGroupNV = NULL;
67		glXQueryMaxSwapGroupsNV = NULL;
68		glXQueryFrameCountNV = NULL;
69		glXResetFrameCountNV = NULL;
	67	/* Do nothing. */ ;
70	68	}
71	69
…	…
101	99	}
102	100
103		Bool GlxExtensionLoader::glXJoinSwapGroupNV(::Display *dpy, GLXDrawable drawable,
104		GLuint group)
	101	Bool GlxExtensionLoader::glXJoinSwapGroupNV(::Display* dpy,
	102	GLXDrawable drawable,
	103	GLuint group)
105	104	{
106		vprASSERT(mGlxFuncs->glXJoinSwapGroupNV != NULL && "Attemped to call unsupported extension.");
107		return mGlxFuncs->glXJoinSwapGroupNV(dpy,drawable,group);
	105	vprASSERT(mGlxFuncs->glXJoinSwapGroupNV != NULL &&
	106	"Attemped to call unsupported extension.");
	107	return mGlxFuncs->glXJoinSwapGroupNV(dpy, drawable, group);
108	108	}
109	109
110		Bool GlxExtensionLoader::glXBindSwapBarrierNV(::Display *dpy, GLuint group, GLuint barrier)
	110	Bool GlxExtensionLoader::glXBindSwapBarrierNV(::Display* dpy, GLuint group,
	111	GLuint barrier)
111	112	{
112		vprASSERT(mGlxFuncs->glXBindSwapBarrierNV != NULL && "Attemped to call unsupported extension.");
113		return mGlxFuncs->glXBindSwapBarrierNV(dpy,group,barrier);
	113	vprASSERT(mGlxFuncs->glXBindSwapBarrierNV != NULL &&
	114	"Attemped to call unsupported extension.");
	115	return mGlxFuncs->glXBindSwapBarrierNV(dpy, group, barrier);
114	116	}
115	117
116		Bool GlxExtensionLoader::glXQuerySwapGroupNV(::Display *dpy, GLXDrawable drawable,
117		GLuint group, GLuint barrier)
	118	Bool GlxExtensionLoader::glXQuerySwapGroupNV(::Display* dpy,
	119	GLXDrawable drawable,
	120	GLuint* group,
	121	GLuint* barrier)
118	122	{
119		vprASSERT(mGlxFuncs->glXQuerySwapGroupNV != NULL && "Attemped to call unsupported extension.");
120		return mGlxFuncs->glXQuerySwapGroupNV(dpy,drawable,group,barrier);
	123	vprASSERT(mGlxFuncs->glXQuerySwapGroupNV != NULL &&
	124	"Attemped to call unsupported extension.");
	125	return mGlxFuncs->glXQuerySwapGroupNV(dpy, drawable, group, barrier);
121	126	}
122	127
123		Bool GlxExtensionLoader::glXQueryMaxSwapGroupsNV(::Display *dpy, int screen,
124		GLuint maxGroups, GLuint maxBarriers)
	128	Bool GlxExtensionLoader::glXQueryMaxSwapGroupsNV(::Display* dpy, int screen,
	129	GLuint* maxGroups,
	130	GLuint* maxBarriers)
125	131	{
126		vprASSERT(mGlxFuncs->glXQueryMaxSwapGroupsNV != NULL && "Attemped to call unsupported extension.");
127		return mGlxFuncs->glXQueryMaxSwapGroupsNV(dpy,screen,maxGroups,maxBarriers);
	132	vprASSERT(mGlxFuncs->glXQueryMaxSwapGroupsNV != NULL &&
	133	"Attemped to call unsupported extension.");
	134	return mGlxFuncs->glXQueryMaxSwapGroupsNV(dpy, screen, maxGroups,
	135	maxBarriers);
128	136	}
129	137
130		Bool GlxExtensionLoader::glXQueryFrameCountNV(::Display dpy, int screen, GLuint count)
	138	Bool GlxExtensionLoader::glXQueryFrameCountNV(::Display* dpy, int screen,
	139	GLuint* count)
131	140	{
132		vprASSERT(mGlxFuncs->glXQueryFrameCountNV != NULL && "Attemped to call unsupported extension.");
133		return mGlxFuncs->glXQueryFrameCountNV(dpy,screen,count);
	141	vprASSERT(mGlxFuncs->glXQueryFrameCountNV != NULL &&
	142	"Attemped to call unsupported extension.");
	143	return mGlxFuncs->glXQueryFrameCountNV(dpy, screen, count);
134	144	}
135	145
136		Bool GlxExtensionLoader::glXResetFrameCountNV(::Display *dpy, int screen)
	146	Bool GlxExtensionLoader::glXResetFrameCountNV(::Display* dpy, int screen)
137	147	{
138		vprASSERT(mGlxFuncs->glXResetFrameCountNV != NULL && "Attemped to call unsupported extension.");
139		return mGlxFuncs->glXResetFrameCountNV(dpy,screen);
	148	vprASSERT(mGlxFuncs->glXResetFrameCountNV != NULL &&
	149	"Attemped to call unsupported extension.");
	150	return mGlxFuncs->glXResetFrameCountNV(dpy, screen);
140	151	}
141	152
142	153	} // namespace vrj
143
144

juggler/trunk/modules/vrjuggler/vrj/Draw/OGL/GlxExtensionLoader.h

r19729	r19883
28	28	#define VRJ_GLX_EXTENSION_LOADER_H_
29	29
30		#include <vrj/Draw/OGL/GlExtensionLoader.h>
	30	#include <vrj/Draw/OGL/Config.h>
	31
31	32	#include <boost/shared_ptr.hpp>
32	33	#include <GL/glx.h>
	34
	35	#include <vrj/Draw/OGL/GlExtensionLoader.h>
	36
33	37
34	38	namespace vrj
…	…
52	56	bool hasSwapGroupNV();
53	57
54		Bool glXJoinSwapGroupNV(::Display *dpy, GLXDrawable drawable,
55		GLuint group);
	58	Bool glXJoinSwapGroupNV(::Display* dpy, GLXDrawable drawable,
	59	GLuint group);
56	60
57		Bool glXBindSwapBarrierNV(::Display *dpy, GLuint group, GLuint barrier);
	61	Bool glXBindSwapBarrierNV(::Display* dpy, GLuint group, GLuint barrier);
58	62
59		Bool glXQuerySwapGroupNV(::Display *dpy, GLXDrawable drawable,
60		GLuint group, GLuint barrier);
	63	Bool glXQuerySwapGroupNV(::Display* dpy, GLXDrawable drawable,
	64	GLuint* group, GLuint *barrier);
61	65
62		Bool glXQueryMaxSwapGroupsNV(::Display *dpy, int screen,
63		~~GLuint maxGroups,~~ GLuint maxBarriers);
	66	Bool glXQueryMaxSwapGroupsNV(::Display* dpy, int screen, GLuint* maxGroups,
	67	GLuint *maxBarriers);
64	68
65		Bool glXQueryFrameCountNV(::Display ~~dpy, int screen, GLuint ~~count);
	69	Bool glXQueryFrameCountNV(::Display* dpy, int screen, GLuint* count);
66	70
67		Bool glXResetFrameCountNV(::Display *dpy, int screen);
	71	Bool glXResetFrameCountNV(::Display* dpy, int screen);
68	72	//@}
69	73
…	…
76	80	} // namespace vrj
77	81
	82
78	83	#endif
79

Download in other formats: