Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > Model and Texture but with children

Reply
Thread Tools

Model and Texture but with children

 
 
=?ISO-8859-2?Q?Rafa=B3?= Maj
Guest
Posts: n/a
 
      05-23-2007

Say we have a class Model (a 3d model) and class Texture (representing an
Texture).

Model have a texture, Model can be Drawed. Texture have method that returns
data needed for drawing.

class Texture {
public:
// openGl data here
glInt GetInt();
};

class Model {
public:
Texture *tex;
void Draw() {
glInt x = tex->GetInt();
// ...
}
};


And all is well.

But now - say I want to make this design more flexible, to have
opengl-texture (and way of drawing for the monster)
and directX-texture (and directX way of drawing of the monster).
So I will make Texture a base class, and move OpenGL stuff into TextureOGL
etc.

class Texture { public: };
class TextureOGL : public cTexture
{ public: /* opengl data */ glInt GetInt(); };
// more Texture*

THE PROBLEM: but what then happens to the monster?
1) how to add methods for drawing in different ways (I want that to be
choosed in runtime)
2) how to access the texture


My possible solutions

Solution-1 - only child have texture
class Texture { public: };
class TextureOGL : public cTexture { public: /*...*/ glInt GetInt(); };
class cMonster { virtual void Draw()=0; };
class cMonsterOGL : public cMonster { public:
cTextureOGL *tex;
virtual void Draw() { tex->GetInt(); /*...*/ }
};

Almost ideal but that doesnt modell that EVERY monster always have SOME
texture (and that information migt be needee)


Solution-2
class Texture { public: virtual string Name(); };
class TextureOGL : public cTexture { public: /*...*/ glInt GetInt(); };
class cMonster { public: cTexture *tex; virtual void Draw()=0;
void GeneralUseOfTexture() { MsgBox(tex->Name()); }
};
class cMonsterOGL : public cMonster { public:
virtual void Draw() {
dynamic_cast<cTextureOGL>(tex)->GetInt(); /*...*/
// else/catch - wrong dynamic cast - print error "Wrong texture!"
}
};
That models all informations and allow general use of texture ->Name();
The problem is - it uses a dynamic_cast with is consider not so good, also I
wonder about speed implications.. upcast is fast and O(1) or not really?

Other solutions?

Perhaps using templates... but writting entire Monster<T> implementation
inside header .h is not too good since its complicated class.
Also it would be not so easy to have a std::vector of monsters etc.













 
Reply With Quote
 
 
 
 
Howard
Guest
Posts: n/a
 
      05-23-2007

"Rafal Maj" <(E-Mail Removed)> wrote in message
news:f327v2$89l$(E-Mail Removed)...
>
> Say we have a class Model (a 3d model) and class Texture (representing an
> Texture).
>
> Model have a texture, Model can be Drawed. Texture have method that
> returns
> data needed for drawing.
>
> class Texture {
> public:
> // openGl data here
> glInt GetInt();
> };
>
> class Model {
> public:
> Texture *tex;
> void Draw() {
> glInt x = tex->GetInt();
> // ...
> }
> };
>
>
> And all is well.
>
> But now - say I want to make this design more flexible, to have
> opengl-texture (and way of drawing for the monster)
> and directX-texture (and directX way of drawing of the monster).
> So I will make Texture a base class, and move OpenGL stuff into TextureOGL
> etc.
>
> class Texture { public: };
> class TextureOGL : public cTexture
> { public: /* opengl data */ glInt GetInt(); };
> // more Texture*
>
> THE PROBLEM: but what then happens to the monster?
> 1) how to add methods for drawing in different ways (I want that to be
> choosed in runtime)
> 2) how to access the texture
>
>
> My possible solutions
>
> Solution-1 - only child have texture
> class Texture { public: };
> class TextureOGL : public cTexture { public: /*...*/ glInt GetInt(); };
> class cMonster { virtual void Draw()=0; };
> class cMonsterOGL : public cMonster { public:
> cTextureOGL *tex;
> virtual void Draw() { tex->GetInt(); /*...*/ }
> };
>
> Almost ideal but that doesnt modell that EVERY monster always have SOME
> texture (and that information migt be needee)
>


I'm not sure what it means when you say every monstre has SOME texture.
What's the relationship between an OpenGL texture and a DirectX texture?
Are they actually related, or just somewhat similar in concept? If they're
not related, then perhaps thinking of them as the same thing is wrong to
begin with.

>
> Solution-2
> class Texture { public: virtual string Name(); };
> class TextureOGL : public cTexture { public: /*...*/ glInt GetInt(); };
> class cMonster { public: cTexture *tex; virtual void Draw()=0;
> void GeneralUseOfTexture() { MsgBox(tex->Name()); }
> };
> class cMonsterOGL : public cMonster { public:
> virtual void Draw() {
> dynamic_cast<cTextureOGL>(tex)->GetInt(); /*...*/
> // else/catch - wrong dynamic cast - print error "Wrong
> texture!"
> }
> };
> That models all informations and allow general use of texture ->Name();
> The problem is - it uses a dynamic_cast with is consider not so good, also
> I
> wonder about speed implications.. upcast is fast and O(1) or not really?
>
> Other solutions?
>
> Perhaps using templates... but writting entire Monster<T> implementation
> inside header .h is not too good since its complicated class.
> Also it would be not so easy to have a std::vector of monsters etc.
>


Perhaps what you need is to separate the monster and the texture from each
other? After all, changing how the monster is rendered shouldn't have to
change the monster itself. (Especially if you can change how they're drawn
at run-time.)

One solution would be to make another object which contains (or points to) a
monster and a texture, thus associating the two. That owner monster/texture
object would know how to Draw(), using the texture type it's designed for
and monster it's associated with.

So, you might create a vector of OpenGL monster/texture owner objects, or
you might create a vector of DirectX monster/texture owner objects,
depending on the user choice (or whatever).

And besides Draw(), any other manipulations that involve both the monster
and the texture could be done via virtual members of the appropriate type of
monster/texture owner object. And the monster would hold a pointer to the
base-class (possible pure abstract?) of the monster/texture owner, so calls
from either a Monster or one of the Texture classes would be polymorphic,
removing any concern on the Monster's part as to what type of owner object
(and thus what type of texture) it's working with.

Here's an example, where the textures need not be related at all:

class Monster;
class Texture_OpenGL;
class Texture_DirectX;

class MonsterTextureOwner
{
Monster* pMonster;
...whatever...
virtual void DrawMonster() = 0;
virtual ~MonsterTextureOwner();
};

class MonsterTextureOwner_OpenGL
{
Texture_OpenGL textureOGL;
...
virtual void DrawMonster();
...
~MonsterTextureOwner_OpenGL();
};

class MonsterTextureOwner_DirectX
{
Texture_DirectX textureDX;
...
virtual void DrawMonster();
...
~MonsterTextureOwner_DirectX();
};

class Monster
{
MonsterTextureOwner* pOwner;
...
void Draw() { if (pOwner) pOwner->DrawMonster() }
};

-Howard


 
Reply With Quote
 
 
 
 
Howard
Guest
Posts: n/a
 
      05-24-2007

"Howard" <(E-Mail Removed)> wrote in message
news:go35i.20091$(E-Mail Removed)...
>


>
> Here's an example, where the textures need not be related at all:
>
> class Monster;
> class Texture_OpenGL;
> class Texture_DirectX;
>
> class MonsterTextureOwner
> {
> Monster* pMonster;
> ...whatever...
> virtual void DrawMonster() = 0;
> virtual ~MonsterTextureOwner();
> };
>
> class MonsterTextureOwner_OpenGL


oops. Should have added ": public MonsterTextureOwner" there

> {
> Texture_OpenGL textureOGL;
> ...
> virtual void DrawMonster();
> ...
> ~MonsterTextureOwner_OpenGL();
> };
>
> class MonsterTextureOwner_DirectX



Ditto: should have added ": public MonsterTextureOwner" there

> {
> Texture_DirectX textureDX;
> ...
> virtual void DrawMonster();
> ...
> ~MonsterTextureOwner_DirectX();
> };
>
> class Monster
> {
> MonsterTextureOwner* pOwner;
> ...
> void Draw() { if (pOwner) pOwner->DrawMonster() }
> };
>
> -Howard
>
>



 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Problem with texture of UI stacey Java 3 01-23-2007 03:36 PM
texture on my inkjet photo prints gypsy3001@yahoo.com Digital Photography 5 10-12-2005 08:43 AM
Texture mapping in Java 2D! plank@plank.com Java 5 09-02-2005 03:17 PM
Changing CreateQuad() defined Texture - D3D Xpyder C++ 3 03-05-2005 12:09 AM
DiMAGE A2 For Video and Texture Aquisition Tesselator Digital Photography 0 07-08-2004 05:18 PM



Advertisments