Thread: [cgkit-user] Using the object loaders in other code.
Brought to you by:
mbaas
From: R. D. <re...@gm...> - 2008-04-08 02:08:37
|
Hello, is there a way to use the obj loader, and viewer in another pyopengl application? I've started to try doing this by hacking up viewer.py to remove parts I don't need. I guess I need a way to figure out how to run the viewer in my own mainloop. So instead of a run() method, have all the parts separated. cheers, |
From: Matthias B. <mat...@gm...> - 2008-04-08 21:31:36
|
René Dudfield wrote: > is there a way to use the obj loader, Yes. > and viewer in another pyopengl application? Well, the viewer is a simple visualization application that isn't meant to be embedded as a whole inside another application. But you might have noticed that it is a fairly tiny application and the bulk of the work is inside the Python package which is reusable. Now you could use the package at various levels, depending on what you want to do. Let's begin at the lowest level: - The module "cgkit.objmtl" allows you to parse an OBJ (and MTL) file and process the data that is in those files (see http://cgkit.sourceforge.net/doc2/module-cgkit.objmtl.html) . You can derive from the OBJReader class and implement the handler methods that process the data (vertices, faces, etc.). In this case, it is your responsibility to create an appropriate data structure that stores the model and that can display it. - If you want cgkit to handle the object loading, you could simply use the load() function inside the cgkit.cmds module (or import it via cgkit.all), see http://cgkit.sourceforge.net/doc2/commands.html. In this case, you just pass the file name of the OBJ file (or any other format that is supported by cgkit) as argument and the object will be loaded into memory. cgkit maintains its own scene which will then carry the loaded model (the scene is nothing fancy. Think of it as a DOM-like structure that you can use to get to the 3D data). The easiest way to get an idea of what has been loaded into a scene is by using the listWorld() command: >>> from cgkit.all import * >>> load("cube.obj") >>> listWorld() Root +---pCube1 (Polyhedron/PolyhedronGeom) In this case, an object called "pCube1" which is a Polyhedron has been loaded. Have a look at this page to get an idea about how to access the scene: http://cgkit.sourceforge.net/doc2/node102.html Each piece of geometry is represented by a "WorldObject" (which represents the world space transformation) and a "GeomObject" (which represents the actual geometry). Every GeomObject has a method drawGL() which just draws the corresponding geometry in its local object space using OpenGL commands (http://cgkit.sourceforge.net/doc2/node154.html). So in your own application you could use this to draw the model. Every other OpenGL-related aspect (opening a window, setting up viewport, camera, lights, applying materials and transformations, etc.) would then still be up to you. - There is a class GLRenderInstance which is used inside the viewer tool. I just noticed that this class isn't documented, sorry. Basically, what it does is it just draws the entire scene using the above drawGL() methods and does everything that you would have to do yourself in the above case (except from opening an OpenGL context). The class is fairly simple and it doesn't do any fancy optimizations or tricks. Have a look at the draw() method inside viewer.py to see how it is initialized and used. I hope one of those approaches suits your application. Cheers, - Matthias - |
From: R. D. <re...@gm...> - 2008-04-08 23:08:35
|
Thanks Matthias for the detailed reply. I'll post back with my experiences over the next couple of days. Cheers, On Wed, Apr 9, 2008 at 7:31 AM, Matthias Baas <mat...@gm...> wrote: > René Dudfield wrote: > > > is there a way to use the obj loader, > > > > Yes. > > > > > and viewer in another pyopengl application? > > > > Well, the viewer is a simple visualization application that isn't meant to > be embedded as a whole inside another application. > But you might have noticed that it is a fairly tiny application and the > bulk of the work is inside the Python package which is reusable. > > Now you could use the package at various levels, depending on what you want > to do. Let's begin at the lowest level: > > - The module "cgkit.objmtl" allows you to parse an OBJ (and MTL) file and > process the data that is in those files (see > http://cgkit.sourceforge.net/doc2/module-cgkit.objmtl.html) . You can derive > from the OBJReader class and implement the handler methods that process the > data (vertices, faces, etc.). In this case, it is your responsibility to > create an appropriate data structure that stores the model and that can > display it. > > - If you want cgkit to handle the object loading, you could simply use the > load() function inside the cgkit.cmds module (or import it via cgkit.all), > see http://cgkit.sourceforge.net/doc2/commands.html. In this case, you just > pass the file name of the OBJ file (or any other format that is supported by > cgkit) as argument and the object will be loaded into memory. cgkit > maintains its own scene which will then carry the loaded model (the scene is > nothing fancy. Think of it as a DOM-like structure that you can use to get > to the 3D data). The easiest way to get an idea of what has been loaded into > a scene is by using the listWorld() command: > > >>> from cgkit.all import * > >>> load("cube.obj") > >>> listWorld() > Root > +---pCube1 (Polyhedron/PolyhedronGeom) > > In this case, an object called "pCube1" which is a Polyhedron has been > loaded. Have a look at this page to get an idea about how to access the > scene: http://cgkit.sourceforge.net/doc2/node102.html > Each piece of geometry is represented by a "WorldObject" (which represents > the world space transformation) and a "GeomObject" (which represents the > actual geometry). Every GeomObject has a method drawGL() which just draws > the corresponding geometry in its local object space using OpenGL commands > (http://cgkit.sourceforge.net/doc2/node154.html). So in your own application > you could use this to draw the model. Every other OpenGL-related aspect > (opening a window, setting up viewport, camera, lights, applying materials > and transformations, etc.) would then still be up to you. > > - There is a class GLRenderInstance which is used inside the viewer tool. I > just noticed that this class isn't documented, sorry. Basically, what it > does is it just draws the entire scene using the above drawGL() methods and > does everything that you would have to do yourself in the above case (except > from opening an OpenGL context). The class is fairly simple and it doesn't > do any fancy optimizations or tricks. Have a look at the draw() method > inside viewer.py to see how it is initialized and used. > > > I hope one of those approaches suits your application. > > Cheers, > > - Matthias - > > |
From: R. D. <re...@gm...> - 2008-04-09 06:51:20
|
hi again, Are textures supported by the objloader + viewer? It looks like they are with the viewer, but I can't seem to see any displayed. On Wed, Apr 9, 2008 at 7:31 AM, Matthias Baas <mat...@gm...> wrote: > René Dudfield wrote: > > > is there a way to use the obj loader, > > > > Yes. > > > > > and viewer in another pyopengl application? > > > > Well, the viewer is a simple visualization application that isn't meant to > be embedded as a whole inside another application. > But you might have noticed that it is a fairly tiny application and the > bulk of the work is inside the Python package which is reusable. > > Now you could use the package at various levels, depending on what you want > to do. Let's begin at the lowest level: > > - The module "cgkit.objmtl" allows you to parse an OBJ (and MTL) file and > process the data that is in those files (see > http://cgkit.sourceforge.net/doc2/module-cgkit.objmtl.html) . You can derive > from the OBJReader class and implement the handler methods that process the > data (vertices, faces, etc.). In this case, it is your responsibility to > create an appropriate data structure that stores the model and that can > display it. > > - If you want cgkit to handle the object loading, you could simply use the > load() function inside the cgkit.cmds module (or import it via cgkit.all), > see http://cgkit.sourceforge.net/doc2/commands.html. In this case, you just > pass the file name of the OBJ file (or any other format that is supported by > cgkit) as argument and the object will be loaded into memory. cgkit > maintains its own scene which will then carry the loaded model (the scene is > nothing fancy. Think of it as a DOM-like structure that you can use to get > to the 3D data). The easiest way to get an idea of what has been loaded into > a scene is by using the listWorld() command: > > >>> from cgkit.all import * > >>> load("cube.obj") > >>> listWorld() > Root > +---pCube1 (Polyhedron/PolyhedronGeom) > > In this case, an object called "pCube1" which is a Polyhedron has been > loaded. Have a look at this page to get an idea about how to access the > scene: http://cgkit.sourceforge.net/doc2/node102.html > Each piece of geometry is represented by a "WorldObject" (which represents > the world space transformation) and a "GeomObject" (which represents the > actual geometry). Every GeomObject has a method drawGL() which just draws > the corresponding geometry in its local object space using OpenGL commands > (http://cgkit.sourceforge.net/doc2/node154.html). So in your own application > you could use this to draw the model. Every other OpenGL-related aspect > (opening a window, setting up viewport, camera, lights, applying materials > and transformations, etc.) would then still be up to you. > > - There is a class GLRenderInstance which is used inside the viewer tool. I > just noticed that this class isn't documented, sorry. Basically, what it > does is it just draws the entire scene using the above drawGL() methods and > does everything that you would have to do yourself in the above case (except > from opening an OpenGL context). The class is fairly simple and it doesn't > do any fancy optimizations or tricks. Have a look at the draw() method > inside viewer.py to see how it is initialized and used. > > > I hope one of those approaches suits your application. > > Cheers, > > - Matthias - > > |
From: Matthias B. <mat...@gm...> - 2008-04-09 21:09:37
|
René Dudfield wrote: > Are textures supported by the objloader + viewer? It looks like they > are with the viewer, but I can't seem to see any displayed. Well, in principle textures are supported, it's just that not all materials are currently displayable in the viewer tool (whereas you would see the textures when you render the scene using RenderMan). When OBJ models are loaded, the material is stored as an OBJMaterial object (http://cgkit.sourceforge.net/doc2/objmaterial.html). But the "native" material for OpenGL renderings is the GLMaterial object (http://cgkit.sourceforge.net/doc2/node164.html). So at the moment you would have to replace the material on your model with an appropriate GLMaterial object (which you might base on the values in the OBJMaterial object). Getting/setting material objects on a model is done via the WorldObject's getMaterial()/setMaterial() methods (see http://cgkit.sourceforge.net/doc2/node125.html). - Matthias - |
From: R. D. <re...@gm...> - 2008-04-10 04:53:10
|
ah ok. So I need to make a OBJMaterial -> GLMaterial method. Thanks again. On Thu, Apr 10, 2008 at 7:09 AM, Matthias Baas <mat...@gm...> wrote: > René Dudfield wrote: > > > Are textures supported by the objloader + viewer? It looks like they > > are with the viewer, but I can't seem to see any displayed. > > > > Well, in principle textures are supported, it's just that not all materials > are currently displayable in the viewer tool (whereas you would see the > textures when you render the scene using RenderMan). > > When OBJ models are loaded, the material is stored as an OBJMaterial object > (http://cgkit.sourceforge.net/doc2/objmaterial.html). But the "native" > material for OpenGL renderings is the GLMaterial object > (http://cgkit.sourceforge.net/doc2/node164.html). > So at the moment you would have to replace the material on your model with > an appropriate GLMaterial object (which you might base on the values in the > OBJMaterial object). > Getting/setting material objects on a model is done via the WorldObject's > getMaterial()/setMaterial() methods (see > http://cgkit.sourceforge.net/doc2/node125.html). > > - Matthias - > > |
From: Matthias B. <mat...@gm...> - 2008-04-10 19:47:21
|
René Dudfield wrote: > ah ok. > > So I need to make a OBJMaterial -> GLMaterial method. For the moment, this is the safest thing to do, yes. I had a look into the code again and just saw that there is some initial support for doing this automatically, but it currently only uses the diffuse color (so objects that have different diffuse colors (Kd) should be properly colored in the viewer). In the current version, the OBJMaterial is actually derived from the GLMaterial class, but it doesn't map all attributes yet. I suppose I have to review this entire code at some time and come up with a proper solution. I'd say converting it manually by creating a new GLMaterial object is the best bet the moment as you will then have full control about how attributes are mapped anyway. Usually, all the data can be accessed via attribute access on the material objects. The names are just the same as the corresponding parameters to the constructor. Let me know if this works for you or if there's a problem with it. Cheers, - Matthias - > On Thu, Apr 10, 2008 at 7:09 AM, Matthias Baas <mat...@gm...> wrote: >> René Dudfield wrote: >> >>> Are textures supported by the objloader + viewer? It looks like they >>> are with the viewer, but I can't seem to see any displayed. >>> >> Well, in principle textures are supported, it's just that not all materials >> are currently displayable in the viewer tool (whereas you would see the >> textures when you render the scene using RenderMan). >> >> When OBJ models are loaded, the material is stored as an OBJMaterial object >> (http://cgkit.sourceforge.net/doc2/objmaterial.html). But the "native" >> material for OpenGL renderings is the GLMaterial object >> (http://cgkit.sourceforge.net/doc2/node164.html). >> So at the moment you would have to replace the material on your model with >> an appropriate GLMaterial object (which you might base on the values in the >> OBJMaterial object). >> Getting/setting material objects on a model is done via the WorldObject's >> getMaterial()/setMaterial() methods (see >> http://cgkit.sourceforge.net/doc2/node125.html). >> >> - Matthias - >> >> > |
From: R. D. <re...@gm...> - 2008-04-11 05:47:33
|
Hello, I've made a little test here: http://rene.f0o.com/~rene/stuff/showobj.zip Where I create a new GLMaterial with a new texture. However it doesn't seem to view with a texture applied. Any ideas what I'm doing wrong? cheers, On Fri, Apr 11, 2008 at 5:37 AM, Matthias Baas <mat...@gm...> wrote: > René Dudfield wrote: > > > ah ok. > > > > So I need to make a OBJMaterial -> GLMaterial method. > > > > For the moment, this is the safest thing to do, yes. > I had a look into the code again and just saw that there is some initial > support for doing this automatically, but it currently only uses the diffuse > color (so objects that have different diffuse colors (Kd) should be properly > colored in the viewer). > In the current version, the OBJMaterial is actually derived from the > GLMaterial class, but it doesn't map all attributes yet. I suppose I have to > review this entire code at some time and come up with a proper solution. > I'd say converting it manually by creating a new GLMaterial object is the > best bet the moment as you will then have full control about how attributes > are mapped anyway. > > Usually, all the data can be accessed via attribute access on the material > objects. The names are just the same as the corresponding parameters to the > constructor. > > Let me know if this works for you or if there's a problem with it. > > Cheers, > > - Matthias - > > > > > > > > On Thu, Apr 10, 2008 at 7:09 AM, Matthias Baas <mat...@gm...> > wrote: > > > > > René Dudfield wrote: > > > > > > > > > > Are textures supported by the objloader + viewer? It looks like they > > > > are with the viewer, but I can't seem to see any displayed. > > > > > > > > > > > Well, in principle textures are supported, it's just that not all > materials > > > are currently displayable in the viewer tool (whereas you would see the > > > textures when you render the scene using RenderMan). > > > > > > When OBJ models are loaded, the material is stored as an OBJMaterial > object > > > (http://cgkit.sourceforge.net/doc2/objmaterial.html). But the "native" > > > material for OpenGL renderings is the GLMaterial object > > > (http://cgkit.sourceforge.net/doc2/node164.html). > > > So at the moment you would have to replace the material on your model > with > > > an appropriate GLMaterial object (which you might base on the values in > the > > > OBJMaterial object). > > > Getting/setting material objects on a model is done via the > WorldObject's > > > getMaterial()/setMaterial() methods (see > > > http://cgkit.sourceforge.net/doc2/node125.html). > > > > > > - Matthias - > > > > > > > > > > > > > > > |
From: R. D. <re...@gm...> - 2008-04-11 06:55:37
|
hi again, Instead I replaced the OBJMaterial with the GLMaterial I created - rather than having both materials on the object. However the texture seems to be applied incorrectly. Here's the screenshot comparing it to wings3d displaying the model: http://rene.f0o.com/~rene/stuff/obj_loader_compared_to_wings.png I'm not sure what's wrong there... I tried flipping the image, but it didn't seem to work. Any ideas? Note: I had to comment out the line in cgkit/glmaterial.py #self.shininess = shininess here's the zip with the demo: http://rene.f0o.com/~rene/stuff/showobj.zip viewer.py showobj.py cheers, On Fri, Apr 11, 2008 at 3:47 PM, René Dudfield <re...@gm...> wrote: > Hello, > > I've made a little test here: > http://rene.f0o.com/~rene/stuff/showobj.zip > > Where I create a new GLMaterial with a new texture. > > However it doesn't seem to view with a texture applied. > > Any ideas what I'm doing wrong? > > > cheers, > > > > > > On Fri, Apr 11, 2008 at 5:37 AM, Matthias Baas <mat...@gm...> wrote: > > René Dudfield wrote: > > > > > ah ok. > > > > > > So I need to make a OBJMaterial -> GLMaterial method. > > > > > > > For the moment, this is the safest thing to do, yes. > > I had a look into the code again and just saw that there is some initial > > support for doing this automatically, but it currently only uses the diffuse > > color (so objects that have different diffuse colors (Kd) should be properly > > colored in the viewer). > > In the current version, the OBJMaterial is actually derived from the > > GLMaterial class, but it doesn't map all attributes yet. I suppose I have to > > review this entire code at some time and come up with a proper solution. > > I'd say converting it manually by creating a new GLMaterial object is the > > best bet the moment as you will then have full control about how attributes > > are mapped anyway. > > > > Usually, all the data can be accessed via attribute access on the material > > objects. The names are just the same as the corresponding parameters to the > > constructor. > > > > Let me know if this works for you or if there's a problem with it. > > > > Cheers, > > > > - Matthias - > > > > > > > > > > > > > > > On Thu, Apr 10, 2008 at 7:09 AM, Matthias Baas <mat...@gm...> > > wrote: > > > > > > > René Dudfield wrote: > > > > > > > > > > > > > Are textures supported by the objloader + viewer? It looks like they > > > > > are with the viewer, but I can't seem to see any displayed. > > > > > > > > > > > > > > Well, in principle textures are supported, it's just that not all > > materials > > > > are currently displayable in the viewer tool (whereas you would see the > > > > textures when you render the scene using RenderMan). > > > > > > > > When OBJ models are loaded, the material is stored as an OBJMaterial > > object > > > > (http://cgkit.sourceforge.net/doc2/objmaterial.html). But the "native" > > > > material for OpenGL renderings is the GLMaterial object > > > > (http://cgkit.sourceforge.net/doc2/node164.html). > > > > So at the moment you would have to replace the material on your model > > with > > > > an appropriate GLMaterial object (which you might base on the values in > > the > > > > OBJMaterial object). > > > > Getting/setting material objects on a model is done via the > > WorldObject's > > > > getMaterial()/setMaterial() methods (see > > > > http://cgkit.sourceforge.net/doc2/node125.html). > > > > > > > > - Matthias - > > > > > > > > > > > > > > > > > > > > > > > |
From: R. D. <re...@gm...> - 2008-04-11 07:27:24
|
Could it be related to texcoords? Are the texcoords being used? On Fri, Apr 11, 2008 at 4:55 PM, René Dudfield <re...@gm...> wrote: > hi again, > > Instead I replaced the OBJMaterial with the GLMaterial I created - > rather than having both materials on the object. > > However the texture seems to be applied incorrectly. > > Here's the screenshot comparing it to wings3d displaying the model: > http://rene.f0o.com/~rene/stuff/obj_loader_compared_to_wings.png > > I'm not sure what's wrong there... I tried flipping the image, but it > didn't seem to work. > > Any ideas? > > > > Note: I had to comment out the line in cgkit/glmaterial.py > #self.shininess = shininess > here's the zip with the demo: > > http://rene.f0o.com/~rene/stuff/showobj.zip > > > viewer.py showobj.py > > > cheers, > > > > > > On Fri, Apr 11, 2008 at 3:47 PM, René Dudfield <re...@gm...> wrote: > > Hello, > > > > I've made a little test here: > > http://rene.f0o.com/~rene/stuff/showobj.zip > > > > Where I create a new GLMaterial with a new texture. > > > > However it doesn't seem to view with a texture applied. > > > > Any ideas what I'm doing wrong? > > > > > > cheers, > > > > > > > > > > > > On Fri, Apr 11, 2008 at 5:37 AM, Matthias Baas <mat...@gm...> wrote: > > > René Dudfield wrote: > > > > > > > ah ok. > > > > > > > > So I need to make a OBJMaterial -> GLMaterial method. > > > > > > > > > > For the moment, this is the safest thing to do, yes. > > > I had a look into the code again and just saw that there is some initial > > > support for doing this automatically, but it currently only uses the diffuse > > > color (so objects that have different diffuse colors (Kd) should be properly > > > colored in the viewer). > > > In the current version, the OBJMaterial is actually derived from the > > > GLMaterial class, but it doesn't map all attributes yet. I suppose I have to > > > review this entire code at some time and come up with a proper solution. > > > I'd say converting it manually by creating a new GLMaterial object is the > > > best bet the moment as you will then have full control about how attributes > > > are mapped anyway. > > > > > > Usually, all the data can be accessed via attribute access on the material > > > objects. The names are just the same as the corresponding parameters to the > > > constructor. > > > > > > Let me know if this works for you or if there's a problem with it. > > > > > > Cheers, > > > > > > - Matthias - > > > > > > > > > > > > > > > > > > > > > > On Thu, Apr 10, 2008 at 7:09 AM, Matthias Baas <mat...@gm...> > > > wrote: > > > > > > > > > René Dudfield wrote: > > > > > > > > > > > > > > > > Are textures supported by the objloader + viewer? It looks like they > > > > > > are with the viewer, but I can't seem to see any displayed. > > > > > > > > > > > > > > > > > Well, in principle textures are supported, it's just that not all > > > materials > > > > > are currently displayable in the viewer tool (whereas you would see the > > > > > textures when you render the scene using RenderMan). > > > > > > > > > > When OBJ models are loaded, the material is stored as an OBJMaterial > > > object > > > > > (http://cgkit.sourceforge.net/doc2/objmaterial.html). But the "native" > > > > > material for OpenGL renderings is the GLMaterial object > > > > > (http://cgkit.sourceforge.net/doc2/node164.html). > > > > > So at the moment you would have to replace the material on your model > > > with > > > > > an appropriate GLMaterial object (which you might base on the values in > > > the > > > > > OBJMaterial object). > > > > > Getting/setting material objects on a model is done via the > > > WorldObject's > > > > > getMaterial()/setMaterial() methods (see > > > > > http://cgkit.sourceforge.net/doc2/node125.html). > > > > > > > > > > - Matthias - > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > |
From: Matthias B. <mat...@gm...> - 2008-04-12 18:50:47
|
René Dudfield wrote: > I've made a little test here: > http://rene.f0o.com/~rene/stuff/showobj.zip Don't you get an exception on this example? I do because some values are set to None whereas a proper value is expected (I guess I should always add proper validation). Anyway, as you have found out yourself, you have to replace the material instead of adding it. The OpenGL renderer will just use the first material in the list (currently, it's only the RenderMan renderer that can make use of several materials). Bay the way, when you create objects like materials, world objects or geom objects you should rather use keyword arguments instead of positional arguments (I'm not even sure if the order in the manual is always the same as in the code). The only convention I have is that the name (if an object has one) is the first argument but for all other arguments I don't guarantee that the order will stay the same across versions. > Where I create a new GLMaterial with a new texture. > However it doesn't seem to view with a texture applied. > [...] > Could it be related to texcoords? Are the texcoords being used? You are on the right track here. Yes, texture coordinates are being used (you always need them when mapping in image to an object). And the problem is that depending on what package is used a v coordinate of 0 can either be at the top or the bottom of the image. So it can be necessary that you flip the v coordinate (which is equivalent to mirroring the image in y direction). You can do this by adding a transformation to the texture object. For example: GLTexture(..., transform = mat4.scaling((1,-1,1)), ... ) This transformation matrix is applied to every texture coordinate and in this example it replaces v by -v. - Matthias - |
From: R. D. <re...@gm...> - 2008-04-14 01:51:32
|
Hi, I had an error with the shininess attribute - which isn't specified in the C++ version of the GLMaterial class - only in the python wrapper. I've changed the calls to use kwargs. I tried using the texture matrix like you suggested, but that doesn't fix it. Here's the updated test(with .obj file included): http://rene.f0o.com/~rene/stuff/showobj.zip cheers, On Sun, Apr 13, 2008 at 4:50 AM, Matthias Baas <mat...@gm...> wrote: > René Dudfield wrote: > > > I've made a little test here: > > http://rene.f0o.com/~rene/stuff/showobj.zip > > > > Don't you get an exception on this example? I do because some values are > set to None whereas a proper value is expected (I guess I should always add > proper validation). > Anyway, as you have found out yourself, you have to replace the material > instead of adding it. The OpenGL renderer will just use the first material > in the list (currently, it's only the RenderMan renderer that can make use > of several materials). > > Bay the way, when you create objects like materials, world objects or geom > objects you should rather use keyword arguments instead of positional > arguments (I'm not even sure if the order in the manual is always the same > as in the code). The only convention I have is that the name (if an object > has one) is the first argument but for all other arguments I don't guarantee > that the order will stay the same across versions. > > > > > > Where I create a new GLMaterial with a new texture. > > However it doesn't seem to view with a texture applied. > > [...] > > > > Could it be related to texcoords? Are the texcoords being used? > > > > You are on the right track here. Yes, texture coordinates are being used > (you always need them when mapping in image to an object). > And the problem is that depending on what package is used a v coordinate of > 0 can either be at the top or the bottom of the image. So it can be > necessary that you flip the v coordinate (which is equivalent to mirroring > the image in y direction). You can do this by adding a transformation to the > texture object. For example: > > GLTexture(..., > transform = mat4.scaling((1,-1,1)), > ... > ) > > This transformation matrix is applied to every texture coordinate and in > this example it replaces v by -v. > > - Matthias - > > |
From: R. D. <re...@gm...> - 2008-04-14 02:52:30
|
Hi again, I found my problem with shininess - I was supplying a vector, and the class needed a scalar float. I still have the problem with the texture being applied incorrectly though. cheers, On Mon, Apr 14, 2008 at 11:51 AM, René Dudfield <re...@gm...> wrote: > Hi, > > I had an error with the shininess attribute - which isn't specified in > the C++ version of the GLMaterial class - only in the python wrapper. > > I've changed the calls to use kwargs. > > I tried using the texture matrix like you suggested, but that doesn't fix it. > > Here's the updated test(with .obj file included): > > http://rene.f0o.com/~rene/stuff/showobj.zip > > cheers, > > > > > > On Sun, Apr 13, 2008 at 4:50 AM, Matthias Baas <mat...@gm...> wrote: > > René Dudfield wrote: > > > > > I've made a little test here: > > > http://rene.f0o.com/~rene/stuff/showobj.zip > > > > > > > Don't you get an exception on this example? I do because some values are > > set to None whereas a proper value is expected (I guess I should always add > > proper validation). > > Anyway, as you have found out yourself, you have to replace the material > > instead of adding it. The OpenGL renderer will just use the first material > > in the list (currently, it's only the RenderMan renderer that can make use > > of several materials). > > > > Bay the way, when you create objects like materials, world objects or geom > > objects you should rather use keyword arguments instead of positional > > arguments (I'm not even sure if the order in the manual is always the same > > as in the code). The only convention I have is that the name (if an object > > has one) is the first argument but for all other arguments I don't guarantee > > that the order will stay the same across versions. > > > > > > > > > > Where I create a new GLMaterial with a new texture. > > > However it doesn't seem to view with a texture applied. > > > [...] > > > > > > Could it be related to texcoords? Are the texcoords being used? > > > > > > > You are on the right track here. Yes, texture coordinates are being used > > (you always need them when mapping in image to an object). > > And the problem is that depending on what package is used a v coordinate of > > 0 can either be at the top or the bottom of the image. So it can be > > necessary that you flip the v coordinate (which is equivalent to mirroring > > the image in y direction). You can do this by adding a transformation to the > > texture object. For example: > > > > GLTexture(..., > > transform = mat4.scaling((1,-1,1)), > > ... > > ) > > > > This transformation matrix is applied to every texture coordinate and in > > this example it replaces v by -v. > > > > - Matthias - > > > > > |
From: Matthias B. <mat...@gm...> - 2008-04-14 19:56:51
|
René Dudfield wrote: > I tried using the texture matrix like you suggested, but that doesn't fix it. You have set the wrap modes to GL_CLAMP, but as we are just negating the texture coordinate we actually end up with coordinates that are "out of range". This doesn't matter as long as we are using GL_REPEAT (which is the default) because in this case the texture image is repeated in texture space. If for some reason you need to use GL_CLAMP you must translate the texture coordinate back into the valid range (0-1). For example: transform = mat4.scaling((1,-1,1)) transform.translate((0,-1,0)) Sorry for the confusion. - Matthias - |
From: R. D. <re...@gm...> - 2008-04-14 22:52:31
|
aha! indeed, that does the trick. Thanks a lot. On Tue, Apr 15, 2008 at 5:56 AM, Matthias Baas <mat...@gm...> wrote: > René Dudfield wrote: > > > I tried using the texture matrix like you suggested, but that doesn't fix > it. > > > > You have set the wrap modes to GL_CLAMP, but as we are just negating the > texture coordinate we actually end up with coordinates that are "out of > range". This doesn't matter as long as we are using GL_REPEAT (which is the > default) because in this case the texture image is repeated in texture > space. > If for some reason you need to use GL_CLAMP you must translate the texture > coordinate back into the valid range (0-1). For example: > > > transform = mat4.scaling((1,-1,1)) > transform.translate((0,-1,0)) > > Sorry for the confusion. > > - Matthias - > > |
From: R. D. <re...@gm...> - 2008-04-17 07:57:21
|
hi again, I now have most of my scene loading and displaying with cgkit... however I am having a couple of issues with display speed: - textures are loaded multiple times, and not shared. - performance is really slow - probably because of the textures. eg. this concrete1.tga image gets loaded 16 times - wasting a lot of texture memory. Loading "concrete1.tga"...Texname: 33 ... Loading "concrete1.tga"...Texname: 49 Have you any ideas on how to make materials be reused? I was thinking of making a cache somewhere, but I'm not really sure where I should place it. Display lists. =========== Also, do you have any ideas on how to create and use a display list for the scene? The scene isn't animated at all, so a display list should speed it up nicely. Is this already supported? Here's a function which can be used to make, and use display lists for a given draw_obj function. def display_with_list(draw_obj, obj_id): if not obj_id: obj_id = glGenLists(1) glNewList (obj_id, GL_COMPILE_AND_EXECUTE) draw_obj() glEndList() else: glCallList(obj_id) return obj_id On Tue, Apr 15, 2008 at 8:52 AM, René Dudfield <re...@gm...> wrote: > aha! indeed, that does the trick. > > Thanks a lot. > > > > > On Tue, Apr 15, 2008 at 5:56 AM, Matthias Baas <mat...@gm...> wrote: > > René Dudfield wrote: > > > > > I tried using the texture matrix like you suggested, but that doesn't fix > > it. > > > > > > > You have set the wrap modes to GL_CLAMP, but as we are just negating the > > texture coordinate we actually end up with coordinates that are "out of > > range". This doesn't matter as long as we are using GL_REPEAT (which is the > > default) because in this case the texture image is repeated in texture > > space. > > If for some reason you need to use GL_CLAMP you must translate the texture > > coordinate back into the valid range (0-1). For example: > > > > > > transform = mat4.scaling((1,-1,1)) > > transform.translate((0,-1,0)) > > > > Sorry for the confusion. > > > > - Matthias - > > > > > |
From: Matthias B. <mat...@gm...> - 2008-04-17 21:14:25
|
René Dudfield wrote: > I now have most of my scene loading and displaying with cgkit... > however I am having a couple of issues with display speed: > > - textures are loaded multiple times, and not shared. > - performance is really slow - probably because of the textures. > > eg. this concrete1.tga image gets loaded 16 times - wasting a lot of > texture memory. > Loading "concrete1.tga"...Texname: 33 > ... > Loading "concrete1.tga"...Texname: 49 > > Have you any ideas on how to make materials be reused? I was thinking > of making a cache somewhere, but I'm not really sure where I should > place it. Separate material (and texture) objects result in separate (and duplicate) usage. There is no internal optimization to check whether two texture objects actually refer to the same image. So you should rather use the same material instance (or just texture object instance) for all geometry. Then the texture would only get loaded once. Writing a function that does this optimization should actually be quite straightforward. Just iterate over the scene and check all texture objects inside the materials. If an object is equivalent to one that has already been visited, then replace the texture with the stored one, otherwise store the texture and go to the next material. > Also, do you have any ideas on how to create and use a display list > for the scene? The scene isn't animated at all, so a display list > should speed it up nicely. Is this already supported? So far, display lists are not used internally (as I said in an earlier mail, the drawing stuff is really pretty simple). But it's not really difficult to get that behavior. The drawing is actually done in C++ but you can hook into it by implementing your own geometry object (in Python) that just has to derive from GeomObject. Inside this class you can put the code that you have posted. Here is an example: ########################################################### from cgkit.geomobject import GeomObject from OpenGL.GL import * class CachedGeom(GeomObject): """Stick geometry into a display list and use the list for drawing. """ def __init__(self, originalGeom): """Constructor. originalGeom must be a GeomObject whose drawGL() method will only be called once to create a display list. """ GeomObject.__init__(self) self.originalGeom = originalGeom self.listId = None def boundingBox(self): """Return the bounding box of the underlying geom.""" return self.originalGeom.boundingBox() def drawGL(self): """Draw the geom object.""" if self.listId is None: self.listId = glGenLists(1) glNewList(self.listId, GL_COMPILE_AND_EXECUTE) self.originalGeom.drawGL() glEndList() glCallList(self.listId) load("bunny.3ds") bunny = worldObject("Bunny") # Wrap the original geom with a CachedGeom object # that uses a display list for drawing bunny.geom = CachedGeom(bunny.geom) ############################################################# You can run this with the viewer tool (it's using the bunny model which is available in the svn repository in the demos directory. But you can just as well use any of your own models as this just serves as an example). The CachedGeom class takes another GeomObject as input and simply uses its drawGL() method once to fill the display list. In subsequent drawing operations, the list will then be used. So if you wrap all your geometry with this cache class, everything should become quite a bit faster. Note: It's the same here as in the texture case: If you have several objects that are actually using the same geometry then make sure that the *same* GeomObject instance is used (whereas the WorldObjects differ so that you can position the objects independently). Otherwise, you would again fill your graphics card memory with duplicate data. - Matthias - |