Jogl FAQ - Revision history

Gbarbieri: /* Why you should learn direct from start the modern OpenGL (programmable and shader based) over the deprecated fixed function pipeline */

2015-08-26T12:08:37Z

Why you should learn direct from start the modern OpenGL (programmable and shader based) over the deprecated fixed function pipeline

← Older revision		Revision as of 14:08, 26 August 2015
Line 420:		Line 420:
	In order to say you why you should start right away learning modern OpenGL, I will use the words of [http://web.archive.org/web/20140207031129/http://www.arcsynthesis.org/gltut/About%20this%20Book.html Jason L. McKesson]:		In order to say you why you should start right away learning modern OpenGL, I will use the words of [http://web.archive.org/web/20140207031129/http://www.arcsynthesis.org/gltut/About%20this%20Book.html Jason L. McKesson]:

	"Programmability. Virtually all of the aforementioned sources instruct beginners using something called “fixed functionality.” This represents configurations in older graphics processors that define how a particular rendering operation will proceed. It is generally considered easiest to teach neophyte graphics programmers using the fixed function pipeline.		"
			Programmability. Virtually all of the aforementioned sources instruct beginners using something called “fixed functionality.” This represents configurations in older graphics processors that define how a particular rendering operation will proceed. It is generally considered easiest to teach neophyte graphics programmers using the fixed function pipeline.

	This is considered true because it is easy to get something to happen with fixed functionality. It's simpler to make pictures that look like something real. The fixed function pipeline is like training wheels for a bicycle.		This is considered true because it is easy to get something to happen with fixed functionality. It's simpler to make pictures that look like something real. The fixed function pipeline is like training wheels for a bicycle.
Line 434:		Line 435:
	Another problem is that, even if you truly understand the fixed function pipeline, it limits how you think about solving problems. Because of its inflexibility, it focuses your mind along certain problem solving possibilities and away from others. It encourages you to think of textures as pictures; vertex data as texture coordinates, colors, or positions; and the like. By its very nature, it limits creativity and problem solving.		Another problem is that, even if you truly understand the fixed function pipeline, it limits how you think about solving problems. Because of its inflexibility, it focuses your mind along certain problem solving possibilities and away from others. It encourages you to think of textures as pictures; vertex data as texture coordinates, colors, or positions; and the like. By its very nature, it limits creativity and problem solving.

	Lastly, even on mobile systems, fixed functionality is generally not available in the graphics hardware. Programmability is the order of the day for most graphics hardware, and this will only become more true in the future."		Lastly, even on mobile systems, fixed functionality is generally not available in the graphics hardware. Programmability is the order of the day for most graphics hardware, and this will only become more true in the future.
			"

Gbarbieri: /* Why you should learn direct from start the modern OpenGL (programmable and shader based) over the deprecated fixed function pipeline */

2015-08-26T12:08:18Z

Why you should learn direct from start the modern OpenGL (programmable and shader based) over the deprecated fixed function pipeline

← Older revision		Revision as of 14:08, 26 August 2015
Line 420:		Line 420:
	In order to say you why you should start right away learning modern OpenGL, I will use the words of [http://web.archive.org/web/20140207031129/http://www.arcsynthesis.org/gltut/About%20this%20Book.html Jason L. McKesson]:		In order to say you why you should start right away learning modern OpenGL, I will use the words of [http://web.archive.org/web/20140207031129/http://www.arcsynthesis.org/gltut/About%20this%20Book.html Jason L. McKesson]:

	"~~'''~~Programmability. Virtually all of the aforementioned sources instruct beginners using something called “fixed functionality.” This represents configurations in older graphics processors that define how a particular rendering operation will proceed. It is generally considered easiest to teach neophyte graphics programmers using the fixed function pipeline.		"Programmability. Virtually all of the aforementioned sources instruct beginners using something called “fixed functionality.” This represents configurations in older graphics processors that define how a particular rendering operation will proceed. It is generally considered easiest to teach neophyte graphics programmers using the fixed function pipeline.

	This is considered true because it is easy to get something to happen with fixed functionality. It's simpler to make pictures that look like something real. The fixed function pipeline is like training wheels for a bicycle.		This is considered true because it is easy to get something to happen with fixed functionality. It's simpler to make pictures that look like something real. The fixed function pipeline is like training wheels for a bicycle.
Line 434:		Line 434:
	Another problem is that, even if you truly understand the fixed function pipeline, it limits how you think about solving problems. Because of its inflexibility, it focuses your mind along certain problem solving possibilities and away from others. It encourages you to think of textures as pictures; vertex data as texture coordinates, colors, or positions; and the like. By its very nature, it limits creativity and problem solving.		Another problem is that, even if you truly understand the fixed function pipeline, it limits how you think about solving problems. Because of its inflexibility, it focuses your mind along certain problem solving possibilities and away from others. It encourages you to think of textures as pictures; vertex data as texture coordinates, colors, or positions; and the like. By its very nature, it limits creativity and problem solving.

	Lastly, even on mobile systems, fixed functionality is generally not available in the graphics hardware. Programmability is the order of the day for most graphics hardware, and this will only become more true in the future.~~'''~~"		Lastly, even on mobile systems, fixed functionality is generally not available in the graphics hardware. Programmability is the order of the day for most graphics hardware, and this will only become more true in the future."

Gbarbieri: /* Why you should learn direct from start the modern OpenGL (programmable and shader based) over the deprecated fixed function pipeline */

2015-08-26T12:07:59Z

Why you should learn direct from start the modern OpenGL (programmable and shader based) over the deprecated fixed function pipeline

← Older revision		Revision as of 14:07, 26 August 2015
Line 420:		Line 420:
	In order to say you why you should start right away learning modern OpenGL, I will use the words of [http://web.archive.org/web/20140207031129/http://www.arcsynthesis.org/gltut/About%20this%20Book.html Jason L. McKesson]:		In order to say you why you should start right away learning modern OpenGL, I will use the words of [http://web.archive.org/web/20140207031129/http://www.arcsynthesis.org/gltut/About%20this%20Book.html Jason L. McKesson]:

	"Programmability. Virtually all of the aforementioned sources instruct beginners using something called “fixed functionality.” This represents configurations in older graphics processors that define how a particular rendering operation will proceed. It is generally considered easiest to teach neophyte graphics programmers using the fixed function pipeline.		"'''Programmability. Virtually all of the aforementioned sources instruct beginners using something called “fixed functionality.” This represents configurations in older graphics processors that define how a particular rendering operation will proceed. It is generally considered easiest to teach neophyte graphics programmers using the fixed function pipeline.

	This is considered true because it is easy to get something to happen with fixed functionality. It's simpler to make pictures that look like something real. The fixed function pipeline is like training wheels for a bicycle.		This is considered true because it is easy to get something to happen with fixed functionality. It's simpler to make pictures that look like something real. The fixed function pipeline is like training wheels for a bicycle.
Line 434:		Line 434:
	Another problem is that, even if you truly understand the fixed function pipeline, it limits how you think about solving problems. Because of its inflexibility, it focuses your mind along certain problem solving possibilities and away from others. It encourages you to think of textures as pictures; vertex data as texture coordinates, colors, or positions; and the like. By its very nature, it limits creativity and problem solving.		Another problem is that, even if you truly understand the fixed function pipeline, it limits how you think about solving problems. Because of its inflexibility, it focuses your mind along certain problem solving possibilities and away from others. It encourages you to think of textures as pictures; vertex data as texture coordinates, colors, or positions; and the like. By its very nature, it limits creativity and problem solving.

	Lastly, even on mobile systems, fixed functionality is generally not available in the graphics hardware. Programmability is the order of the day for most graphics hardware, and this will only become more true in the future."		Lastly, even on mobile systems, fixed functionality is generally not available in the graphics hardware. Programmability is the order of the day for most graphics hardware, and this will only become more true in the future.'''"

Gbarbieri: /* Why you should learn direct from start the modern OpenGL (programmable and shader based) over the deprecated fixed function pipeline */

2015-08-26T12:06:09Z

Why you should learn direct from start the modern OpenGL (programmable and shader based) over the deprecated fixed function pipeline

← Older revision		Revision as of 14:06, 26 August 2015
Line 418:		Line 418:
	I see everyday A LOT of beginers who start with the old deprecated OpenGL. This is wrong, this is so wrong. [https://github.com/elect86/ I, personally,] went through this and today I realize I did it wrong and I wished someone could have told me that at the time I start.		I see everyday A LOT of beginers who start with the old deprecated OpenGL. This is wrong, this is so wrong. [https://github.com/elect86/ I, personally,] went through this and today I realize I did it wrong and I wished someone could have told me that at the time I start.

	In order to say you why you should start right away learning modern OpenGL, I will use the words of Jason L. McKesson:		In order to say you why you should start right away learning modern OpenGL, I will use the words of [http://web.archive.org/web/20140207031129/http://www.arcsynthesis.org/gltut/About%20this%20Book.html Jason L. McKesson]:

	"Programmability. Virtually all of the aforementioned sources instruct beginners using something called “fixed functionality.” This represents configurations in older graphics processors that define how a particular rendering operation will proceed. It is generally considered easiest to teach neophyte graphics programmers using the fixed function pipeline.		"Programmability. Virtually all of the aforementioned sources instruct beginners using something called “fixed functionality.” This represents configurations in older graphics processors that define how a particular rendering operation will proceed. It is generally considered easiest to teach neophyte graphics programmers using the fixed function pipeline.

Gbarbieri: /* Why you should learn direct from start the modern OpenGL (programmable and shader based) over the deprecated fixed function pipeline */

2015-08-26T12:05:34Z

Why you should learn direct from start the modern OpenGL (programmable and shader based) over the deprecated fixed function pipeline

← Older revision		Revision as of 14:05, 26 August 2015
Line 420:		Line 420:
	In order to say you why you should start right away learning modern OpenGL, I will use the words of Jason L. McKesson:		In order to say you why you should start right away learning modern OpenGL, I will use the words of Jason L. McKesson:

	Programmability. Virtually all of the aforementioned sources instruct beginners using something called “fixed functionality.” This represents configurations in older graphics processors that define how a particular rendering operation will proceed. It is generally considered easiest to teach neophyte graphics programmers using the fixed function pipeline.		"Programmability. Virtually all of the aforementioned sources instruct beginners using something called “fixed functionality.” This represents configurations in older graphics processors that define how a particular rendering operation will proceed. It is generally considered easiest to teach neophyte graphics programmers using the fixed function pipeline.

	This is considered true because it is easy to get something to happen with fixed functionality. It's simpler to make pictures that look like something real. The fixed function pipeline is like training wheels for a bicycle.		This is considered true because it is easy to get something to happen with fixed functionality. It's simpler to make pictures that look like something real. The fixed function pipeline is like training wheels for a bicycle.
Line 426:		Line 426:
	There are downsides to this approach. First, much of what is learned with this approach must be inevitably abandoned when the user encounters a graphics problem that must be solved with programmability. Programmability wipes out almost all of the fixed function pipeline, so the knowledge does not easily transfer.		There are downsides to this approach. First, much of what is learned with this approach must be inevitably abandoned when the user encounters a graphics problem that must be solved with programmability. Programmability wipes out almost all of the fixed function pipeline, so the knowledge does not easily transfer.

	A more insidious problem is that the fixed function pipeline can give the illusion of knowledge. A user can think they understand what they are doing, but they're really just copy-and-pasting code around. Programming thus becomes akin to magical rituals: you put certain bits of code before other bits, and everything seems to work.		A more insidious problem is that the fixed function pipeline can give the ''illusion'' of knowledge. A user can think they understand what they are doing, but they're really just copy-and-pasting code around. Programming thus becomes akin to magical rituals: you put certain bits of code before other bits, and everything seems to work.

	This makes debugging nightmarish. Because the user never really understood what the code does, the user is unable to diagnose what a particular problem could possibly mean. And without that ability, debugging becomes a series of random guesses as to what the problem is.		This makes debugging nightmarish. Because the user never really understood what the code does, the user is unable to diagnose what a particular problem could possibly mean. And without that ability, debugging becomes a series of random guesses as to what the problem is.

	By contrast, you cannot use a programmable system successfully without first understanding it. Confronting programmable graphics hardware means confronting issues that fixed function materials often gloss over. This may mean a slower start overall, but when you finally get to the end, you truly know how everything works.		By contrast, you cannot use a programmable system successfully without first understanding it. Confronting programmable graphics hardware means confronting issues that fixed function materials often gloss over. This may mean a slower start overall, but when you finally get to the end, you truly ''know'' how everything works.

	Another problem is that, even if you truly understand the fixed function pipeline, it limits how you think about solving problems. Because of its inflexibility, it focuses your mind along certain problem solving possibilities and away from others. It encourages you to think of textures as pictures; vertex data as texture coordinates, colors, or positions; and the like. By its very nature, it limits creativity and problem solving.		Another problem is that, even if you truly understand the fixed function pipeline, it limits how you think about solving problems. Because of its inflexibility, it focuses your mind along certain problem solving possibilities and away from others. It encourages you to think of textures as pictures; vertex data as texture coordinates, colors, or positions; and the like. By its very nature, it limits creativity and problem solving.

	Lastly, even on mobile systems, fixed functionality is generally not available in the graphics hardware. Programmability is the order of the day for most graphics hardware, and this will only become more true in the future.		Lastly, even on mobile systems, fixed functionality is generally not available in the graphics hardware. Programmability is the order of the day for most graphics hardware, and this will only become more true in the future."

Gbarbieri: /* Why you should learn direct from start the modern OpenGL (programmable and shader based) over the deprecated fixed function pipeline */

2015-08-26T12:04:08Z

Why you should learn direct from start the modern OpenGL (programmable and shader based) over the deprecated fixed function pipeline

← Older revision		Revision as of 14:04, 26 August 2015
Line 416:		Line 416:
	== Why you should learn direct from start the modern OpenGL (programmable and shader based) over the deprecated fixed function pipeline ==		== Why you should learn direct from start the modern OpenGL (programmable and shader based) over the deprecated fixed function pipeline ==

	I see everyday A LOT of beginers who start with the old deprecated OpenGL. This is wrong, this is so wrong. [https://github.com/elect86/ I] went through this and I did it wrong ~~because nobody~~ told me ~~different~~.		I see everyday A LOT of beginers who start with the old deprecated OpenGL. This is wrong, this is so wrong. [https://github.com/elect86/ I, personally,] went through this and today I realize I did it wrong and I wished someone could have told me that at the time I start.

			In order to say you why you should start right away learning modern OpenGL, I will use the words of Jason L. McKesson:

			Programmability. Virtually all of the aforementioned sources instruct beginners using something called “fixed functionality.” This represents configurations in older graphics processors that define how a particular rendering operation will proceed. It is generally considered easiest to teach neophyte graphics programmers using the fixed function pipeline.

			This is considered true because it is easy to get something to happen with fixed functionality. It's simpler to make pictures that look like something real. The fixed function pipeline is like training wheels for a bicycle.

			There are downsides to this approach. First, much of what is learned with this approach must be inevitably abandoned when the user encounters a graphics problem that must be solved with programmability. Programmability wipes out almost all of the fixed function pipeline, so the knowledge does not easily transfer.

			A more insidious problem is that the fixed function pipeline can give the illusion of knowledge. A user can think they understand what they are doing, but they're really just copy-and-pasting code around. Programming thus becomes akin to magical rituals: you put certain bits of code before other bits, and everything seems to work.

			This makes debugging nightmarish. Because the user never really understood what the code does, the user is unable to diagnose what a particular problem could possibly mean. And without that ability, debugging becomes a series of random guesses as to what the problem is.

			By contrast, you cannot use a programmable system successfully without first understanding it. Confronting programmable graphics hardware means confronting issues that fixed function materials often gloss over. This may mean a slower start overall, but when you finally get to the end, you truly know how everything works.

			Another problem is that, even if you truly understand the fixed function pipeline, it limits how you think about solving problems. Because of its inflexibility, it focuses your mind along certain problem solving possibilities and away from others. It encourages you to think of textures as pictures; vertex data as texture coordinates, colors, or positions; and the like. By its very nature, it limits creativity and problem solving.

			Lastly, even on mobile systems, fixed functionality is generally not available in the graphics hardware. Programmability is the order of the day for most graphics hardware, and this will only become more true in the future.

Gbarbieri at 12:00, 26 August 2015

2015-08-26T12:00:18Z

← Older revision		Revision as of 14:00, 26 August 2015
Line 413:		Line 413:
	Sometimes you might want to do OpenGL work without a visible GLDrawable or before making your drawable visible.		Sometimes you might want to do OpenGL work without a visible GLDrawable or before making your drawable visible.
	* http://jogamp.762907.n3.nabble.com/Binding-textures-without-showing-the-GLCanvas-tp960145p960234.html		* http://jogamp.762907.n3.nabble.com/Binding-textures-without-showing-the-GLCanvas-tp960145p960234.html

			== Why you should learn direct from start the modern OpenGL (programmable and shader based) over the deprecated fixed function pipeline ==

			I see everyday A LOT of beginers who start with the old deprecated OpenGL. This is wrong, this is so wrong. [https://github.com/elect86/ I] went through this and I did it wrong because nobody told me different.

Sgothel at 20:06, 21 January 2014

2014-01-21T20:06:55Z

← Older revision		Revision as of 22:06, 21 January 2014
Line 265:		Line 265:
	See:		See:
	* [[Using JOGL in a Java applet\|Using JOGL in a Java Applet]]		* [[Using JOGL in a Java applet\|Using JOGL in a Java Applet]]
	* [{{SERVER}}/jogl/doc/deployment/JOGL-DEPLOYMENT.html#~~TraditionalApplets~~ JOGL Deployment ~~for traditional Applets~~]		* [{{SERVER}}/jogl/doc/deployment/JOGL-DEPLOYMENT.html#NApplets JOGL Deployment as an NApplet]

	== What is ''Newt's'' Threading Model for native window events ? ==		== What is ''Newt's'' Threading Model for native window events ? ==

Gouessej: /* What are the Runtime OpenGL Version Requirements ? */ typo

2014-01-14T14:07:59Z

What are the Runtime OpenGL Version Requirements ?: typo

← Older revision		Revision as of 16:07, 14 January 2014
Line 20:		Line 20:

	'''JOGL requires at least an OpenGL version 1.1''',		'''JOGL requires at least an OpenGL version 1.1''',
	due to ~~it's~~ dynamical function binding starting with OpenGL 1.2.		due to its dynamical function binding starting with OpenGL 1.2.

	== Use and test Autobuilds ==		== Use and test Autobuilds ==

Xranby: /* JOGL Demos */ Update links java.net -> jogamp.org

2013-10-03T22:02:40Z

JOGL Demos: Update links java.net -> jogamp.org

← Older revision		Revision as of 00:02, 4 October 2013
Line 40:		Line 40:
	Let’s assume we are in the test directory ‘test’, from which we operate from this point.		Let’s assume we are in the test directory ‘test’, from which we operate from this point.

	* Get [http://~~download~~.~~java.net~~/~~media~~/~~jogl~~/~~builds/nightly~~/jogl-demos.~~zip~~ jogl-demos.~~zip~~]. Extract the archive, i.e. <pre>~~unzip~~ jogl-demos.~~zip~~</pre>		* Get [http://jogamp.org/deployment/jogamp-current/archive/jogl-demos.7z jogl-demos.7z]. Extract the archive, i.e. [http://www.7-zip.org/7z.html <pre>7z x jogl-demos.7z</pre>]

	* Get [http://~~download~~.~~java.net~~/~~media~~/~~jogl~~/~~builds~~/~~nightly/ jogl~~-2.0-~~pre-20090702-linux~~-~~amd64~~.~~zip~~]. ~~In case we have build a reference implementation (RI)~~ the ~~substring ‘pre-yyyymmdd-’ will be dropped~~. ~~Replace the version 2~~.~~0 with the latest available and the OS~~/~~arch linux~~-~~amd64 with your test platform~~. ~~Extract the archive, ie~~ <pre>~~unzip jogl~~-~~2.0~~-~~pre-20090702-linux-amd64~~.~~zip~~</pre>. Create a symbolic link or rename the archive directory from ''~~jogl-2.0-pre-20090702~~-~~linux~~-~~amd64~~'' to ''jogl'', ie <pre>ln -s ~~jogl-2.0-pre-20090702~~-~~linux~~-~~amd64~~ jogl</pre>.		* Get [http://jogamp.org/deployment/jogamp-current/archive/jogamp-all-platforms.7z jogamp-all-platforms.7z]. Extract the archive, i.e. [http://www.7-zip.org/7z.html <pre>7z x jogamp-all-platforms.7z</pre>] Create a symbolic link or rename the archive directory from ''jogamp-all-platforms'' to ''jogl'', ie <pre>ln -s jogamp-all-platforms jogl</pre>.
	* If you like to test the binding to NV’s Cg, [http://developer.nvidia.com/object/cg_download.html download and install]		* If you like to test the binding to NV’s Cg, [http://developer.nvidia.com/object/cg_download.html download and install]