#jogamp @ irc.freenode.net - 20140904 05:05:41 (UTC)

20140904 05:05:41 -jogamp- Previous @ http://jogamp.org/log/irc/jogamp_20140903050541.html
20140904 05:05:41 -jogamp- This channel is logged @ http://jogamp.org/log/irc/jogamp_20140904050541.html
20140904 05:37:03 * hauer (~chatzilla@anon) has joined #jogamp
20140904 05:38:57 <hauer> Hi, I want to be able to let the user switch between having a decorated or undecorated window in my application. Since this is impossible to do by the basic swing API, I remove my GLCanvas from the current window, dispose of it and create a new Window that contains the same canvas. As soon as this is done, the JVM crashes with a fatal error ... does anyone know what is happening?
20140904 05:46:04 <sgothel> is your GLEventListener fully functional ? i.e. will it survive init/dispose init/dispose cycles ?
20140904 05:46:21 <sgothel> note, removing your GLEL .. will issue dispose()
20140904 05:46:51 <sgothel> Note: NEWT can toggle decoration
20140904 05:50:29 <hauer> Explain this init dispose cycle
20140904 05:50:42 <sgothel> look at API doc GLAutoDrawable
20140904 05:51:54 <hauer> Okay ... how do I prevent the dispose() method from being called ... ever ... before the application actually shuts down
20140904 05:53:06 <sgothel> look at '
20140904 05:53:09 <sgothel> GLAutoDrawable Reconfiguration'
20140904 05:53:28 <sgothel> if the surface/resource is being pulled - you simply cannot
20140904 05:53:54 <sgothel> you could do attempt to (1) save the context and it's GLEventListener
20140904 05:54:14 <sgothel> or use (2) NewtCanvasAWT and reparent before killing the AWT resource
20140904 05:54:28 <sgothel> or (3) use a shared context to at least keep up the GL data
20140904 05:55:39 <hauer> (1) and (3) seem like possible solutions
20140904 05:56:02 <hauer> I was looking into (3) and I thought I already implemented some kind of working setup
20140904 05:56:37 <sgothel> for (1) .. its a supported utility called GLEventListenerState, look at the source
20140904 05:57:04 <sgothel> (3) can help, however .. init/dispose will get called
20140904 05:57:17 <sgothel> for (1) .. well, it is not ..
20140904 05:57:38 <hauer> I think what I definetly do not want is dispose being called or rather have init be called again
20140904 05:57:48 <sgothel> do a calltrace or 'show reference' of class GLEventListenerState, to see unit tests and usage in JOGL
20140904 05:58:13 <sgothel> but your code shall survive that anyways, since it can happen .. despite GLEventListenerState
20140904 05:58:20 <sgothel> i.e. it should be functional
20140904 06:00:07 <hauer> The thing is I want to provide a library that allows the user to manipulate both the windows around a gl context and a gl context itself - I do not know weather or not it would make for an easier and more understandable framework if the programmer needs to think around having to rerun his initialization code
20140904 06:02:56 <sgothel> - you know that you have to recreate GL ctx if window is pulled, or use the re-association via (1)
20140904 06:03:11 <sgothel> - you know that init/dispose must be impl. by user and yourself
20140904 06:03:17 <sgothel> (avoid leaks)
20140904 06:03:35 <sgothel> - you know that toggling decoration has issues w/ AWT, hence we are talking :)
20140904 06:06:37 <hauer> With pulled you mean "moved" or something else?
20140904 06:07:08 <sgothel> destroyed, disposed .. 'folks call it when e.g. you destroy a building' :)
20140904 06:08:00 <hauer> Hmh I think it IS right now easily possible to recreate the initialiation process for the lib user
20140904 06:11:33 <hauer> Though ... I still do not understand why that whole context needs to be recreated
20140904 06:12:05 <sgothel> what shall we do if a window gets destroyed ?
20140904 06:12:06 <hauer> I mean I literally do not want to change anything that is done internally, I just want to have it displayed on another window
20140904 06:12:35 <sgothel> context is associated w/ the window's drawable
20140904 06:13:01 <hauer> What I thought would work would be: remove canvas from the window, dispose of the window, create new window with different decoration flag (true or false), add canvas to the window again
20140904 06:13:38 <sgothel> yes, if your GLEL is functional
20140904 06:13:38 <hauer> At least when swiching from fullscreen to windowed mode it works fine even though even the display devices display mode changes
20140904 06:13:52 <hauer> Though I do not destroy any windows there
20140904 06:14:01 <hauer> cause for some reason that works just fine
20140904 06:14:07 <sgothel> that is what you _think_ :)
20140904 06:14:28 <sgothel> in AWT removeNotify() is called when native window is destroyed
20140904 06:14:42 <sgothel> i.e. a [GL]Canvas is a native peer itself
20140904 06:14:45 <sgothel> (window)
20140904 06:15:12 <sgothel> all would be solved using NEWT ..
20140904 06:15:44 <hauer> I just realized that if I should "neatly" free any texture or framebuffer ever created on a run of the lib when it get's disposed I have to do a load of irritating bookkeeping internally
20140904 06:16:07 <sgothel> you should do that anyways
20140904 06:16:51 <sgothel> reason (1) exists .. is for performance reasons and to keep the user and GL state alive .. not for the developers convenience :)
20140904 06:17:21 <sgothel> example: android home button pulls the window .. we save the state, when resumed .. we cont.
20140904 06:18:38 <hauer> ... yeah I tried to stay away from android as far as possible after I have done some basic stuff with it for learning purposes ...
20140904 06:19:53 <hauer> What does NEWT do different?
20140904 06:20:40 <sgothel> http://jogamp.org/jogl/doc/NEWT-Overview.html
20140904 06:20:53 <hauer> reading that page already :-P
20140904 06:21:05 <sgothel> and I thought you are resilient .. :)
20140904 06:21:40 <sgothel> I talk about NEWT in our BOFs and FOSDEM session as well .. video/slides
20140904 06:22:22 <hauer> For me I would love to know how much I would have to change in terms of MouseListener, KeyListener and WindowListener code that I have already up and running
20140904 06:22:47 <sgothel> pls look at the unit tests/demos
20140904 06:22:57 <sgothel> our listener are similar
20140904 06:23:37 <hauer> Isn't there some kind of side by side comparism out there?
20140904 06:25:16 <sgothel> sorry, our marketing group just left for breakfast :)
20140904 06:25:34 <sgothel> http://jogamp.org/jogl/doc/NEWT-Overview.html <-
20140904 06:25:53 <sgothel> indeed .. we could update that a bit ..
20140904 06:26:06 <sgothel> maybe you like to do that as a result of this chat ?
20140904 06:26:53 <hauer> Hehe, sorry I am already getting only 3 hours of sleep because I was so engulfed in finding out how to deal with this undecorated stuff :-P
20140904 06:27:31 <hauer> I try to read into some example test cases you guys posted there
20140904 06:27:58 <hauer> and I understand not a word about "how the hell do I get a quick and dirty window open, running and listening to my command"
20140904 06:28:55 <hauer> Actually that is exactly what I want to do with my lib, having an extremly quick and easy setup for 2D game engines to care about bringing live to the screen and not getting arbitrary 200 lines of boilerplate code up and running
20140904 06:29:00 <sgothel> TestRedSquareES2NEWT <-
20140904 06:29:12 <sgothel> TestGearsES2NEWT <-
20140904 06:29:42 <sgothel> however: nothing good can result from 'quick & dirty' .. always need to understand the basics
20140904 06:29:59 <hauer> I was reading into the later one
20140904 06:30:32 <sgothel> RedSquare is more 'vanilla' :)
20140904 06:30:41 <hauer> Where do I even need to start to read to see the beginning of the actual setup / init process? is it "runTest()" ?
20140904 06:31:02 <sgothel> TestRedSquareES2NEWT: ..
20140904 06:31:17 <sgothel> runTestGL .. sure
20140904 06:32:02 <sgothel> glWindow.addGLEventListener(demo); (similar to GLCanvas) ..
20140904 06:32:02 <hauer> "Why does it have to get a capabilities attribute?" is the first thing I thought
20140904 06:32:08 <sgothel> the rest is all NEWT config ..
20140904 06:32:33 <hauer> Ok I need to find that red square thing
20140904 06:32:45 <sgothel> final GLProfile glp = GLProfile.get(GLProfile.GL3);
20140904 06:32:45 <sgothel> final GLCapabilities caps = new GLCapabilities( glp );
20140904 06:32:49 <sgothel> b/c ^^
20140904 06:32:56 <sgothel> for example ..
20140904 06:33:16 <sgothel> if you have configured your IDE well, you have API doc ..
20140904 06:33:39 <hauer> I use eclipse, I can look into any doc if it is available
20140904 06:33:49 <hauer> or even source
20140904 06:33:50 <hauer> I often do
20140904 06:34:01 <sgothel> so you have it .. attached our source-zip files to the jar files
20140904 06:34:12 <hauer> yes I have
20140904 06:34:13 <sgothel> same w/ the jogl-test !
20140904 06:34:15 <sgothel> great
20140904 06:34:24 <hauer> uhm
20140904 06:34:29 <hauer> that I do not know
20140904 06:34:35 <sgothel> jogl-test <- the unit tests
20140904 06:34:42 <sgothel> has a source zip as well, since 2.2.0
20140904 06:39:20 <hauer> Heh, typing in "JOGL NEWT Tutorial" on google gets me a link to a stackoverflow article where someone complains that he finds no tutorial on that matter and the first person directs him into looking into your unit tests ... I like the topic guy and dislike that answer :-P
20140904 06:40:27 <sgothel> you are not here to make friends, are you ? :)
20140904 06:41:49 <hauer> I don't realy know if I was living naive or you guys are doing something wrong :-P
20140904 06:42:36 <sgothel> if you like to help enhance our wiki and docs .. you are more than welcome
20140904 06:42:47 <hauer> Whenever I read up about anything but JOGL I find tutorials, quick code examples, guides and some kind of way to learn by doing - and none of those things are done by displaying a unit test
20140904 06:43:02 <hauer> the word unit test actually causes fear and dispair in anyone I know
20140904 06:43:15 <sgothel> oh well
20140904 06:43:26 <hauer> thats why I always have to raise an eyebrow when you tell me to look at them
20140904 06:43:34 <sgothel> it is the best proof and doc for developer
20140904 06:44:00 <sgothel> yes, it's open source - free software, use the source + API doc
20140904 06:44:02 <hauer> I don't need proof that it works I need to know how I get it to work
20140904 06:44:11 <sgothel> I do spend quite some time writing the API doc
20140904 06:44:46 <sgothel> thats a bit naive IMHO - if you like to choose a tool for your product, you need proof
20140904 06:45:14 <hauer> Yeah that is also a thing ... I don't do all that in a "product" way
20140904 06:45:15 <sgothel> and the unit test works, it is proven .. hence you can learn reading it how to use the API
20140904 06:45:20 <hauer> I work that as a hobby
20140904 06:45:29 <hauer> and as a hobby I want it to work
20140904 06:45:49 <hauer> not to have proof that it complies to corporate security standards
20140904 06:45:53 <sgothel> you can do whatever you want in whatever modus operandi ofc - you are free (I hope and wish)
20140904 06:46:30 <hauer> I am a slave to my own ignorance and thought of "there has to be a happy sunshine rainbow way of doing this that noone has yet told me about"
20140904 06:46:34 <sgothel> (doesn't matter if you do it as a hobby for free .. or for a million bucks IMHO)
20140904 06:47:07 <sgothel> well - it is my goal and of jogamp, to make life easy, just the definition of easy may differ a little bit
20140904 06:47:29 <sgothel> in a good tutorial you will find one most important thing: code snippets ..
20140904 06:47:30 <hauer> Nah ... I played Firefall as it came out of it's Beta last week, and I was so freaking amused that they did not bind the "Exit Vehicle" and "Meele Attack" buttons to anything, that I can still laugh about this
20140904 06:47:41 <sgothel> thats what our unit tests are all about
20140904 06:47:44 <hauer> it is horrible QA testing
20140904 06:48:04 <hauer> but it is so sweet to see that in a double A title this gets forgotten
20140904 06:48:10 <hauer> and if something like that goes wrong
20140904 06:48:13 <hauer> I can smile :-D
20140904 06:48:43 <hauer> oh and in terms of code snippets
20140904 06:49:50 <hauer> "To get newt running: 4 lines of code" that is a code snippet tutorial, and if I don't know anything about what that 4 lines of code do, but if I copy and paste them into my program and I get to see some resutl - that hooks me into wanting to know more
20140904 06:50:58 <sgothel> you do have a point here .. sure the learning curve shall not be too steep
20140904 06:51:09 <hauer> if I need to read through 5 unit tests, 100 lines of wierd config code and have no clue why something happens there, it get's me thinking "is that worth it or should I just stick to my guns?"
20140904 06:51:12 <sgothel> TestRedSquareES2NEWT: probably is not too tough
20140904 06:51:45 <hauer> AH
20140904 06:51:48 <hauer> I am so stupid
20140904 06:52:06 <hauer> I typed in RedSquare into my windows search bar and it did not find that test file
20140904 06:52:14 <hauer> when I typed in TestRedSquare it found it
20140904 06:52:16 <hauer> NOW
20140904 06:52:17 <hauer> ARGH
20140904 06:53:14 <hauer> Now if those "tests" would have a main() method so I could just click on the "RUN" button in Eclipse and see the magic happen, that would be best :-P
20140904 06:53:35 <sgothel> sir, they do .. they do
20140904 06:54:15 <hauer> Uh I stand corrected :-D
20140904 06:57:23 <hauer> So to get a NEWT window running I need to call: "GLWindow window = new GLWindow();" "window.addGLEventListener(myListener);" and "Clock myClock = new Clock(init, values, (window -> window.display)" (with the last part being a lambda expression that get's executed 60 times / sec)
20140904 06:58:16 <sgothel> do a window.setVisible(true); before your lambda animator
20140904 06:59:01 <sgothel> however, I recommend using Animator class, which interacts w/ GLAutoDrawable for fluent animation etc
20140904 06:59:04 <hauer> Does your GLWindow support the MouseListener etc. of AWT / Swing ?
20140904 06:59:11 <sgothel> our own
20140904 06:59:31 <hauer> I'll look into that later
20140904 07:01:31 <hauer> And yeah you have that Animator class, though there are two problems with using that: First I can not use my single threaded execution loop that get's used in a lot of ye olde game programming, where you keep track of eventually skipped frames etc. (there is an article about different ways to implement a game logic / rendering loop out there) ... and I do not realy understand the API of the...
20140904 07:01:33 <hauer> ...Animator
20140904 07:01:48 <hauer> like what do I need to call to set the FPS to 30 ... 60 ... 120
20140904 07:02:22 <sgothel> changing the swap interval in the GLEventListener
20140904 07:02:34 <sgothel> i.e. only makes sense using vertical sync
20140904 07:02:40 <sgothel> avoid tearing etc
20140904 07:02:58 <sgothel> otherwise .. you can use FPSAnimator
20140904 07:05:13 <hauer> I do not understand what you mean by "swap interval"
20140904 07:05:28 <sgothel> its a display terminology ..
20140904 07:05:46 <sgothel> i.e. 1 == each frame displayed .. think CRT
20140904 07:06:09 <sgothel> 2 == each other frame, makes 30hz on a 60hz
20140904 07:06:15 <sgothel> 0 == no vsync
20140904 07:06:37 <sgothel> look in RedSquareES2 for setSwap*(..)
20140904 07:13:52 <hauer> Well that 4 lines of code gave me more insight than I ever got
20140904 07:14:05 <hauer> Now I am starting to experiment
20140904 07:14:15 <hauer> and I get less than 3 hours sleep now
20140904 07:14:18 <hauer> well nighty night
20140904 07:14:25 <sgothel> nighty night
20140904 07:14:39 <hauer> And thank you gothel
20140904 07:14:50 * hauer (~chatzilla@anon) Quit (Quit: ChatZilla 0.9.90.1 [Firefox 32.0/20140825202822])
20140904 07:25:12 * jvanek (jvanek@anon) has joined #jogamp
20140904 07:29:09 <monsieur_max1> http://www.theverge.com/2014/9/3/6101929/john-carmack-goes-into-nerd-overdrive-about-vr-on-the-note-4
20140904 07:31:02 * monsieur_max1 is now known as monsieur_max
20140904 10:04:42 * odin_ (~Odin@anon) Quit (Ping timeout: 268 seconds)
20140904 10:19:51 * odin_ (~Odin@anon) has joined #jogamp
20140904 13:06:05 * hauer (~chatzilla@anon) has joined #jogamp
20140904 13:17:47 <hauer> @sgothel Can you give me an idea about how I should be going about implementing a game - loop - logic a'la http://www.koonsolo.com/news/dewitters-gameloop/ when using the JOGL Animator?
20140904 13:25:17 <xranby> hauer: consider the Animator to be the while( game_is_running ) {
20140904 13:25:48 <hauer> I would rather not have my display() method of my GLEventListener call the update_game() method
20140904 13:26:20 <xranby> why not?
20140904 13:26:32 <hauer> representational separation
20140904 13:26:50 <hauer> displaying something onscreen has nothing to do with updating the model state
20140904 13:27:01 <xranby> do you plan to do several game updates between two frame updates?
20140904 13:27:35 <xranby> if you do then you need to run the game logic in its own thread
20140904 13:27:45 <hauer> that is part of customization of the person using my lib
20140904 13:28:07 <hauer> if he wants the game to run at 60 FPS and 120 TPS (Ticks per Second) I want him to be able to do that
20140904 13:28:09 <xranby> and then have some way to send rendering messages to the display loop what to render
20140904 13:28:56 <xranby> hauer: there is nothing stopping you from writing your own animator
20140904 13:29:00 <xranby> i will give you an exampe
20140904 13:29:07 <hauer> I did write my own animator
20140904 13:29:26 <xranby> this book http://www.arcsynthesis.org/gltut/
20140904 13:29:52 <hauer> https://bitbucket.org/salbeira/jsprites-gl/src/fb59c4253631095c3739a490b80ebe1edef30940/src/sprites/base/Clock.java?at=master
20140904 13:29:58 <xranby> has jogamp jogl examples https://github.com/elect86/modern-jogl-examples/
20140904 13:31:39 <xranby> oh.. never mind.. he used the animator framework hmm
20140904 13:31:51 <xranby> thus did not follow the logic of the original book
20140904 13:34:58 <xranby> we have the jake2 port using jogl
20140904 13:35:17 <xranby> that uses a higher game tick count compared to the frames rendered
20140904 13:35:23 <xranby> especially seen on slow hardware
20140904 13:37:49 <xranby> from jogamp perspective, we care that the hardware gets exposed to the programmer without putting restrictions on how you want to use the hardware in your framework or game
20140904 13:44:23 <hauer> Though do you find anything wrong with my clock?
20140904 13:45:18 <xranby> hauer: i have not looked, i expect your code to have unittests
20140904 13:45:24 <xranby> that check the functionality
20140904 13:45:32 <hauer> ok forget I asked
20140904 13:46:01 <hauer> it was more of a "is the idea sound" question
20140904 13:46:09 <xranby> its possible that you need to write tests that verify that your code work the way you expect it to
20140904 13:46:11 <hauer> not a "can you review my code" question
20140904 13:47:10 <hauer> It's an implementation of koonsolo's final idea about integrating rendering and logic loops into a common loop
20140904 13:47:11 <xranby> is there something wrong with the code?
20140904 13:47:32 <hauer> No
20140904 13:48:04 <hauer> I want to gather opinions about how to thematically combine rendering and logic loops
20140904 13:48:39 <xranby> all i can do is give you examples on how other people hav solved the same task
20140904 13:48:50 <xranby> without judging which solution is superior
20140904 13:49:30 <xranby> i would go for a solution that is deterministic
20140904 13:50:25 <hauer> determinism I like
20140904 13:51:15 <xranby> you may have issues with the time granulary
20140904 13:51:38 <xranby> System.currentTimeMillis() will give you the time in system 10ms granulary at best
20140904 13:51:54 <xranby> which is not good enough
20140904 13:52:03 <xranby> because you want 4ms or better for 60hz
20140904 13:52:30 <xranby> in jogamp there exist an api to get the system time using better granularity
20140904 13:55:37 <xranby> hauer: use http://jogamp.org/deployment/v2.2.0/javadoc/gluegen/javadoc/com/jogamp/common/os/Platform.html#currentTimeMicros%28%29
20140904 14:02:37 * monsieur_max (~maxime@anon) Quit (Quit: Leaving.)
20140904 14:17:13 * jvanek (jvanek@anon) Quit (Quit: Leaving)
20140904 14:35:32 * jvanek (jvanek@anon) has joined #jogamp
20140904 14:46:45 * gouessej (5ee4b442@anon) has joined #jogamp
20140904 14:47:21 <gouessej> Hi
20140904 14:47:38 <gouessej> hauer: http://bugs.sun.com/view_bug.do?bug_id=6435126
20140904 14:48:45 <gouessej> hauer: just create a daemon thread that calls Thread.sleep() and System.currentTimeMillis() will become suddenly more accurate
20140904 14:51:54 <gouessej> hauer: Do you really need a shutdown hook?
20140904 14:53:20 * gouessej (5ee4b442@anon) Quit (Quit: Page closed)
20140904 15:07:55 * monsieur_max (~maxime@anon) has joined #jogamp
20140904 15:11:52 * kermyt (~kermyt@anon) Quit (Ping timeout: 245 seconds)
20140904 15:14:14 * kermyt (~kermyt@anon) has joined #jogamp
20140904 15:14:57 * jvanek (jvanek@anon) Quit (Quit: Leaving)
20140904 15:18:20 <hauer> gouessej: if I do not cause the thread to stop, when debugging my lib I always have the clock thread keep running in the background when I close the window, also I might add some kind of cleanup routine that should be called when the loop gets stopped
20140904 15:35:35 <hauer> wierd thing using a NEWT window: When getting close to the edges of a window my mouse curser does not change to a "resize drag and drop" style cursor
20140904 15:37:04 <hauer> Also when undecorated it does not react to ALT + F4
20140904 15:49:27 * gouessej (5ee4b442@anon) has joined #jogamp
20140904 15:50:44 <gouessej> hauer: There is no need of a shutdown hook. You should check in your loop whether your window is still open or you should set your flag to false when closing it instead of using a shutdown hook
20140904 15:51:01 <gouessej> hauer: Why don't you use existing libraries?
20140904 15:51:14 <gouessej> hauer: LibGDX + JOGL backend?
20140904 15:52:11 <hauer> reasons
20140904 15:52:59 <hauer> mainly because I want to have the feeling that I know exactly what is happening in the backend and I do not want to make the full capabilities of OpenGL visible
20140904 15:53:23 <hauer> there is so much you can do, but when you want to do something in 100% 2D you need to work around so much in 3D space
20140904 15:53:56 <hauer> I did all that thinking already and have a working 2D rendering environment running, now I just want to add customizablity with changable window features
20140904 15:54:04 <gouessej> Creating your library is nice for pedagogical purposes, to learn, but you can't make a better library alone
20140904 15:54:17 <hauer> I don't want to :-)
20140904 15:54:24 <hauer> * make a better lib
20140904 15:54:43 <hauer> Its a hobby project I do in my time I should be doing something else
20140904 15:54:46 <hauer> aka. free time
20140904 15:55:10 <gouessej> Are you sure that your undecorated window is focused when you press ALT+F4?
20140904 15:55:48 <gouessej> LibGDX is open source, it's not a black box
20140904 15:59:12 <hauer> ... I guess it sounds very arrogant but I do not want the user of my lib to be able to draw anything but 2D sprites onto a 2D canvas and the user should under no circumstances be confronted with anything that open GL can actually do
20140904 15:59:28 * monsieur_max (~maxime@anon) Quit (Quit: Leaving.)
20140904 15:59:38 <hauer> Using JOGL or LibGDX doesn't realy make a difference here
20140904 16:01:16 <hauer> On another node: Where can I change flags like "resizable" for a NEWT GLWindow?
20140904 16:04:30 <hauer> btw. , on your http://jogamp.org/jogl/doc/NEWT-Overview.html website, the final link at the bottom of the screen redirects to 404
20140904 16:04:45 <hauer> NEWT API Overview : http://jogamp.org/deployment/jogamp-next/javadoc/jogl/javadoc/com/jogamp/newt/package-summary.html
20140904 16:06:17 <gouessej> LibGDX already works out of the box especially for 2D games
20140904 16:06:56 <gouessej> and if you're alone to develop your library, there is a very few chances that you drive it attractive enough for others
20140904 16:07:22 <gouessej> The links work for me
20140904 16:07:33 <gouessej> except the second one :s
20140904 16:07:35 <gouessej> sorry
20140904 16:07:47 <gouessej> Sven is going to fix that in JOGL 2.2.1
20140904 16:08:03 <gouessej> No NEWT classes are in the API documentation :s
20140904 16:09:44 <gouessej> There is a request for enhancement about driving GLWindow not resizable
20140904 16:09:48 <gouessej> not implemented yet
20140904 16:09:50 <gouessej> Bye
20140904 16:09:53 * gouessej (5ee4b442@anon) Quit (Quit: Page closed)
20140904 16:09:55 <hauer> *sigh*
20140904 16:15:21 <hauer> So I am off to write two versions of my initializing code: one that uses Swing and Canvas and does not support dynamically changing decoration and one that uses NEWT and does not support dynamically changing resizablility
20140904 16:15:35 * hauer (~chatzilla@anon) Quit (Quit: ChatZilla 0.9.90.1 [Firefox 32.0/20140825202822])
20140904 16:35:03 * monsieur_max (~maxime@anon) has joined #jogamp
20140904 17:00:51 * zzuegg|afk is now known as zzuegg
20140904 18:04:41 <sgothel> back for a little bit - guess I catched a cold - long sleep
20140904 20:10:02 * monsieur_max sends sun and heat from south of france to sgothel
20140904 20:39:58 * void256 (~chatzilla@anon) has joined #jogamp
20140904 20:48:05 * void256 (~chatzilla@anon) Quit (Remote host closed the connection)
20140904 20:48:27 * void256 (~chatzilla@anon) has joined #jogamp
20140904 20:56:18 * void256_ (~void@anon) has joined #jogamp
20140904 20:57:16 * monsieur_max (~maxime@anon) Quit (Quit: Leaving.)
20140904 22:09:49 * [Mike] (~Mike]@anon) has joined #jogamp
20140904 22:35:04 * void256 (~chatzilla@anon) Quit (Quit: ChatZilla 0.9.90.1 [Firefox 31.0/20140716183446])
20140904 22:39:17 * void256_ (~void@anon) Quit (Quit: ChatZilla 0.9.90.1 [Firefox 31.0/20140716183446])
20140905 05:05:41 -jogamp- Continue @ http://jogamp.org/log/irc/jogamp_20140905050541.html