Discussion :

[yan]

Salut.
Comment peut on appliquer une martice 4x4 sur un mesh de manière dynamique?

J'ai du mal à comprendre ce que représente et comment utiliser world, struct_reference, _ struct_instance, 3Drep, ...

Et je n'arrive pas à savoir qui fait quoi :/

En gros mon mesh affiche une depthMap et je veux appliquer un scale sur les z.

[laumaya]

Salut,

Salut.
Comment peut on appliquer une martice 4x4 sur un mesh de manière dynamique?

J'ai du mal à comprendre ce que représente et comment utiliser world, struct_reference, _ struct_instance, 3Drep, ...

Et je n'arrive pas à savoir qui fait quoi :/

En gros mon mesh affiche une depthMap et je veux appliquer un scale sur les z.

La classe GLC_World permet d'afficher et de gérer une scène constitué d'un assemblage hiérarchique d'objet sous la forme d'un arbre.

La classe GLC_3DRep est une représentation 3D constituée d'une liste GLC_Geometry. Une 3DRep utilise le partage de données.

La classe GLC_StructReference est une référence d'un noeud d'assemblage. Elle peut contenir une représentation 3D.

La classe GLC_StructInstance est une instance de référence. C'est elle qui permet de définir un positionnement relatif au parent par l'utilisation d'une matrice 4x4.

La classe GLC_StructOccurence est une occurrence de référence. Dans un assemblage, contrairement au références et au instances, les occurrences sont unique.

Tu trouveras un exemple dans le chapitre Structure hiérarchique d'une scène de mon article Présentation de GLC_lib

Tu trouveras le diagramme UML de classes sur mon forum en anglais.

Si tu as besoin de structurer ta scène de façon hiérarchique, tu peut appliquer le facteur d'échelle par la matrice 4x4 (GLC_Matrix4x4) d'une des instances (GLC_StructInstance) ou de toute les instances de ton mesh. Ne pas oublier de mettre à jour la matrice absolue de toutes les occurrences de l'instance :
GLC_StructOccurence::updateAbsoluteMatrix()

Si tu n'as pas besoin de structure hiérarchique, tu peux directement utiliser la class GLC_3DViewCollection et appliquer le facteur d'échelle d'une des instances (GLC_3DViewInstance) ou de toute les instances de ton mesh.

Exemple d'utilisation avec GLC_World dont la référence contenant le mesh est connue :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Référence Connue : GLC_StructReference* m_pRef;
// Variable contenant la valeur de scaling : double m_Zscaling;
 
// Création de la matrice de mise à l'échelle
GLC_Matrix4x4 scaling;
scaling.setMatScaling(1.0, 1.0, m_Zscaling);
 
// Mise à jour des matrices relatives des instances
QList<GLC_StructInstance*> listOfInstances= m_pRef->listOfStructInstances();
const int instancesCount= listOfInstances.count();
for (int i= 0; i < instancesCount; ++i)
{
	listOfInstances.at(i)->setMatrix(scaling);
}
 
// Mise à jour des matrices absolues des occurrences
QList<GLC_StructOccurence*> listOfOccurences= m_pRef->listOfStructOccurence();
const int occurencesCount= listOfOccurences.count();
for (int i= 0; i < occurencesCount; ++i)
{
	listOfOccurences.at(i)->updateAbsoluteMatrix();
}

@+

[yan]

Merci pour les explications.
Du coup je n'utilise plus de world. J'utilise un GLC_3DViewInstance ou la boudingbox est bien mise à jour.

Contrairement au GLC_World ou je n'arrivais pas à avoir la boudingbox mise à jour (peut être à cause du updateAbsoluteMatrix() que je n'appelais pas).

La structure world me semble bien compliqué... Je pense qu'il y as possibilité de simplifier tout cela.
Petit proposition, tu devrais utiliser des pointeurs intelligents. Car la gestion mémoire est très difficile à comprendre. On ne sait pas qui va détruire les texture, material, geometry, ...

En tous cas, ta lib est bien pratique pour de petite besoin en 3D
Je vais regarder ton tuto.

[laumaya]

La structure world me semble bien compliqué... Je pense qu'il y as possibilité de simplifier tout cela.

Oui, je sais que la structure world est compliquée.
Mais elle est performante et elle supporte pleinement les concepts d'assemblage structuré implémentés dans le format 3DXML.

Petit proposition, tu devrais utiliser des pointeurs intelligents. Car la gestion mémoire est très difficile à comprendre.

Je vais réfléchir à un moyen de clarifier tous ça.

On ne sait pas qui va détruire les texture, material, geometry, ...

Tous ces objets sont détruits automatiquement quand ils ne sont plus utilisés si ils ont été attribués:
Les textures sont utilisées par des matériaux
Les materials par des géométries
Les géométries par des 3DRep qui sont des pointeurs intelligent.
Les struct : instances, références et occurrences par world.

En tous cas, ta lib est bien pratique pour de petite besoin en 3D

Elle marche aussi pour des gros besoin.

@+

[yan]

Oui, je sais que la structure world est compliquée.
Mais elle est performante et elle supporte pleinement les concepts d'assemblage structuré implémentés dans le format 3DXML.

Je ne dit pas qu'elle est mauvaise, mais juste qu'il y as surement moyen de clarifier les choses . Surtout sur les GCL_StructXXX et le parcoure du scene graph.

Tous ces objets sont détruits automatiquement quand ils ne sont plus utilisés si ils ont été attribués:
Les textures sont utilisées par des matériaux
Les materials par des géométries
Les géométries par des 3DRep qui sont des pointeurs intelligent.
Les struct : instances, références et occurrences par world.

Maintenant je l'ai compris. Mais cela complique des choses pour manipuler le objet 3D. Par exemple partager la même texture ou matériaux entre plusieurs objet. Les smart pointeur simplifieraient tout cela. Surtout que c'est dans le standard maintenant ou y as ceux de Qt qui sont déjà un début.

Si 3Drep est un smartpointeur, pourquoi clone et deepcopy retourne un pointeur??????

[laumaya]

Si 3Drep est un smartpointeur, pourquoi clone et deepcopy retourne un pointeur??????

Pour des raisons discutables de polymorphisme...

[yan]

Pour des raisons discutables de polymorphisme...

Le but du pointeur intelligent est de ne pas avoir à utiliser des pointeurs nue

[laumaya]

Le but du pointeur intelligent est de ne pas avoir à utiliser des pointeurs nue

Complètement d'accord avec toi. Mais comment faire du polymorphisme avec des pointeurs intelligents

Pourquoi les pointeurs intelligent sont ils si peut utilisé dans Qt4
En gros, dans quelles cas les utiliser ou ne pas les utiliser

Je devine la réponse : les pointeurs intelligents sont sécurisant et simple à utiliser mais ils sont moins souple que les pointeurs nues.

[yan]

Complètement d'accord avec toi. Mais comment faire du polymorphisme avec des pointeurs intelligents

C'est à dire? [edit]( en faite j'ai pas compris..)

Pourquoi les pointeurs intelligent sont ils si peut utilisé dans Qt4

à prés partout et en particulier dans les classes implémentant le COW
ou en interne (y as une traduction de dourouc sur les smart pointer dans Qt)
Au niveau QObject, c'est la relation parent-enfant et les signal/slot qui remplace leur utilité. On peut utiliser un qweakpointer pour le partage.
http://doc.qt.nokia.com/4.7/qweakpoi...acking-qobject

En gros, dans quelles cas les utiliser ou ne pas les utiliser

Je dirais là où il faut un pointeur. Sauf cas particulier comme les QObject (et encore).
Au minimum dés que l'on partage l’accès à un pointeur ou que l'on as besoin d'une bonne gestion mémoire.

Je devine la réponse : les pointeurs intelligents sont sécurisant et simple à utiliser mais ils sont moins souple que les pointeurs nues.

pourquoi?
c'est un peu la même chose que tableau C vs std::vector.
C'est aussi souple sauf que la version C++ ajoute des fonctionnalités.

[laumaya]

C'est à dire? [edit]( en faite j'ai pas compris..)

Utilisation du mécanisme de polymorphisme de l'OO.
J'ai une idée, mais ça multiplie le nombre de classe par 2 :
La classe de base est incluse dans un smartPointeur qui est inclus dans une classe emballant le tout...

à prés partout et en particulier dans les classes implémentant le COW

A mon avis, Le COW (Copy On Write) qui est l'un des points fort de Qt répond à un besoin différent.

Pour les QTreeWidget, QListWidget, QTableWidget qui utilisent des Q*WidgetItem qui ne sont pas dérivé de QObject, il faut bien manipuler de pointeurs nues...

Pour les QGraphicsScene qui utilisent des QGraphicsItem qui ne sont pas dérivé de QObject, il faut aussi manipuler des pointeurs nues.

L'utilisation des pointeurs intelligent est donc loin d'être systématique dans Qt d'ou ma question concernant ce choix.

[yan]

Utilisation du mécanisme de polymorphisme de l'OO.
J'ai une idée, mais ça multiplie le nombre de classe par 2 :
La classe de base est incluse dans un smartPointeur qui est inclus dans une classe emballant le tout...

Tu veux du polymorphisme sur un smartpointeur ou sur le pointeur interfacé??

A mon avis, Le COW (Copy On Write) qui est l'un des points fort de Qt répond à un besoin différent.

C'est basé sur les smart pointeur. Aprés ce n'est pas forcement le même besoin que le tien.

Pour les QTreeWidget, QListWidget, QTableWidget qui utilisent des Q*WidgetItem qui ne sont pas dérivé de QObject, il faut bien manipuler de pointeurs nues...

Pour les QGraphicsScene qui utilisent des QGraphicsItem qui ne sont pas dérivé de QObject, il faut aussi manipuler des pointeurs nues.

Il y as la même notion de parent-enfants. Et comme les QObjects, ces objets ne sont pas prévue pour être partagé et sont unique.
Mais une surcouche à base de smart pointeur simplifierais beaucoup de choses.

L'utilisation des pointeurs intelligent est donc loin d'être systématique dans Qt d'ou ma question concernant ce choix.

De l’extérieur c'est vrai et c'est dommage. Mais en interne c'est faux, il y en as beaucoup.

[gbdivers]

Pour les cast des smarts pointeurs, boost (et c++11 maintenant) ont prévu 2 fonctions : static_pointer_cast et dynamic_pointer_cast

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
class A {};
class B : public A {};
B* b = new B;  
shared_ptr<B> sharedB (b);
shared_ptr<A> sharedA = static_pointer_cast<A>(b);
shared_ptr<A> sharedA2 = dynamic_pointer_cast<A>(b);

Ca revient à faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

shared_ptr<A> sharedA = static_cast< shared_ptr<A> >(b.get());

Pour les pointeurs de Qt, QSharedPointer a des fonctions prévues pour :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
QSharedPointer<X> constCast () const;
QSharedPointer<X> dynamicCast () const;
QSharedPointer<X> objectCast () const;
QSharedPointer<X> staticCast () const;
QWeakPointer<T>	toWeakRef () const;

Pour QWeakPointer vers QSharedPointer, il y a des fonctions libres :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
QSharedPointer<X> qSharedPointerCast ( const QWeakPointer<T> & other )
QSharedPointer<X> qSharedPointerConstCast ( const QWeakPointer<T> & other )
QSharedPointer<X> qSharedPointerDynamicCast ( const QWeakPointer<T> & other )
QSharedPointer<X> qSharedPointerObjectCast ( const QWeakPointer<T> & other )
QWeakPointer<X> qWeakPointerCast ( const QWeakPointer<T> & other )

En plus, Qt utilise en interne les macros Q_D et Q_P (je crois) pour l'implémentation de l'ideom Pimp.

A mon avis, Le COW (Copy On Write) qui est l'un des points fort de Qt répond à un besoin différent.

Besoin différent = smart pointeur différent = QSharedDataPointer

[laumaya]

Tu veux du polymorphisme sur un smartpointeur ou sur le pointeur interfacé??

????
Voici un exemple utilisant des pointeurs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
class A
{
public:
	....
	virtual void doSomething()= 0;
	....
};
 
class B : public A
{
public:
	....
	virtual void doSomething()
	{qDebug() << "HELLO World";}
	....
};
class C
{
public:
	C(A* pA)
	: m_pA(pA)
	{}
	inline void hello()
	{m_pA->doSomething();}
private:
	A* m_pA;
};
 
.......
 
void myFunction()
{
	A* pA= new B();
	C myC(pA);
	myC.hello();	
}

Voici ma question :
Comment remplacer le pointeur vers la classe A dans la classe C par un smartpointeur ?

[yan]

Voici ma question :
Comment remplacer le pointeur vers la classe A dans la classe C par un smartpointeur ?

ben... par un smartpointeur sur A.
Dans ton exemple, pourquoi dans un smatpointeur sur A tu ne pourrais pas y mettre B ??

[gbdivers]

+1 Yan, tu peux passer sans problème à des smarts ptr dans ton code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class C
{
public:
    C(QSharedPointer<A> pA) : m_pA(pA) {}
    inline void hello() { m_pA->doSomething(); }
private:
    QSharedPointer<A> m_pA;
};
 
QSharedPointer<A> pA = QSharedPointer<A>(new B());
C myC(pA);
myC.hello();

La seule différence est que tu dois convertir explicitement le pointeur de type B* créé par new en QSharedPointer (le constructeur est explicit)

[laumaya]

ben... par un smartpointeur sur A.
Dans ton exemple, pourquoi dans un smatpointeur sur A tu ne pourrais pas y mettre B ??

Donc à l'utilisation ça donnerai ça si je modifie ma classe C.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
void myFunction()
{
	A* pA= new B();
        QSharedPointer sharedA(pA);
	C myC(sharedA);
	myC.hello();	
}

J'ai du mal à saisir l'intérêt pour l'utilisateur de la classe C

[laumaya]

+1 Yan, tu peux passer sans problème à des smarts ptr dans ton code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class C
{
public:
    C(QSharedPointer<A> pA) : m_pA(pA) {}
    inline void hello() { m_pA->doSomething(); }
private:
    QSharedPointer<A> m_pA;
};
 
QSharedPointer<A> pA = QSharedPointer<A>(new B());
C myC(pA);
myC.hello();

La seule différence est que tu dois convertir explicitement le pointeur de type B* créé par new en QSharedPointer (le constructeur est explicit)

Merci pour l'exemple. Par contre, je ne vois toujours pas la plus value pour l'utilisateur...

[yan]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void myFunction()
{
        QSharedPointer sharedA(new B());
	C myC(sharedA);
       {
            C myC2(sharedA);
 
            //on enlève la reference de sharedA
            sharedA.release()
 
            myC2.hello();
            myC.hello();
        }
	myC.hello();	
}

Dans la deuxième accolades, deux instance de C partage le pointeur.
La destruction de myC2 n'as pas détruit le pointeur car myC le référence.
La destruction de myC, plus personne ne référence le pointeur et il est détruit. (edit : bon on oublie le sharedA )

[gbdivers]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
void myFunction()
{
	A* pA= new B();
        QSharedPointer sharedA(pA);
	C myC(sharedA);
	myC.hello();	
}

J'ai du mal à saisir l'intérêt pour l'utilisateur de la classe C

C'est toujours un problème de gestion de mémoire. Les smarts pointeurs ont 2 avantages :
- l'utilisateur de la classe C n'a pas à se préoccupé de la durée de vie de l'objet B. Imagine que A/B soit un item dans ta vue et que C soit un gestionnaire de scène (singleton... c'est mal ). En quittant le fonction, l'objet B ne doit surement pas être détruit. Il faut donc conserver un pointeur sur cet objet pour le détruire au bon moment ! Et à quel moment ?
(sauf dans le cas où la scène gère la durée de vie des objets... mais dans tous les cas, la responsabilité de la destruction n'est pas laissé à l'utilisateur)
- en cas d'exception après le new, tu peux quitter la fonction avant que la classe C prenne en charge la destruction de l'objet B = fuite mémoire. En travaillant avec un smart pointeur, tu garanties que la mémoire est correctement libérée.

EDIT : +1 pour l'exemple de Yan. Bref, les politiques de destruction des objets peut être très compliquées...

[laumaya]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
void myFunction()
{
        QSharedPointer sharedA(new B());
	C myC(sharedA);
       {
            C myC2(sharedA);
 
            myC2.hello();
            myC.hello();
        }
	myC.hello();	
}

Dans la deuxième accolades, deux instance de C partage le pointeur.
La destruction de myC2 n'as pas détruit le pointeur car myC le référence.
La destruction de myC, plus personne ne référence le pointeur et il est détruit.

Merci, c'est plus claire.
Mais une question me taraude... pour qu'elle raison l'interface de Qt4 n'utilise jamais de QSharedPointer ? (Enfin à ma connaissance.)