Auteur
thellier
thellier
Forum » » Création-Développement » » Microbe3D: besoin d'aide traduction do anglaise
Posté : 08-04-2013 16:21 
=============================================
Microbe3D: Micro Moteur 3D pour les fichiers Wavefront .OBJ utilisant Warp3D
Microbe3D.library: Alain Thellier - Paris - FRANCE - 2011-2013
Pourquoi Microbe3D?
Microbe3D est un petit moteur 3D qui affiche directement des fichiers Wavefront .OBJ
MICROBE3D veut dire "MICRo .OBj Engine for warp3D" (Micro Moteur Warp3D pour fichiers .OBJ)
La philosophie générale est "Faire simple et toujours plus simple"
0) Microbe 3D est rapide et beau
1) Pas besoin de connaitre des centaines de fonctions comme avec OpenGL
2) Pas besoin d'essayer de comprendre comment peut donc fonctionner Warp3D
3) Pas besoin de mettre plein de "States" pour obtenir un effet particulier
4) OpenGL est orienté "traçage" : En permanence vous tracez des faces, des points, des couleurs, etc ..
Mais Microbe3D est orienté objet 3D : il suffit de charger un objet 3D dans la Scene puis de tracer la Scene entière avec une seule fonction
5) Si Microbe3D contient 40 fonctions alors mon but est "Peut-il être fait avec 35 fonctions pour le rendre encore plus simple?"
6) Ainsi quand une fonction fait quelque chose de similaire à une autre, j'essaye de faire une fonction générique qui pourrait traiter différentes "Things" (choses)
7) Pas besoin de savoir ce que vous manipulez: toutes les structures sont privées. Ainsi le programmeur manipule seulement des pointeurs génériques (APTR = une adresse mémoire)
8) Lorsque vous appelez une fonction avec un pointeur sur une "Thing", alors Microbe3D devinera automatiquement ce qu'est cette "Thing" (Object, Scene, Light, Instance)
9) Microbe3D est orienté objet 3D vous ne dessinez pas ni construisez vos objets 3D dans Microbe3D = il suffit de les créer avec vos applications 3D favorites (comme Blender)
Puis de les exporter sous .OBJ. .MTL JPG
[Menu Blender: Fichier/Exporter/Wavefront ( .OBJ)]
10) Maintenant (Fevrier 2013) Microbe3D a 34 fonctions, mais en fait, vous aurez besoin de moins de 10 fonctions Microbe3D pour faire un programme 3D qui marche
11) Avec Microbe3D vous pouvez facilement ajouter un objet 3D en mouvement (logo tournant, etc ..) à vos applications Amiga
12) Mais Microbe3D est encore un petit moteur 3D alors ne vous attendez à créer "Quake" avec
Premier programme Microbe3D
int main(int argc, char *argv[])
{
APTR Scene;
APTR Object;
APTR Instance;
ULONG VanillaKey;
Scene =U3D_EasyOpenScene("Amiga Logo",480,480); /* open a scene in a 480x480 pixels window */
Object=U3D_Read(Scene,"data/AmiLogo.obj"); /* load a 3D object */
if(Object==NULL) goto panic; /* if not loaded then exit */
Instance=U3D_AddInstance(Scene,Object,"Instance"); /* add to scene */
printf(" Esc for quit \n");
while(VanillaKey!=27)
{
U3D_Rotate(Instance,3.0,1.0,4.0,U3D_CHANGE); /* rotate logo */
U3D_DrawScene(Scene); /* draw all */
VanillaKey =U3D_QueryValue(Scene,U3D_VANILLAKEY); /* get keyboard value */
}
panic:
U3D_Delete(Scene); /* close all */
return 0;
}
Tutoriel
Scene
Tout ce que vous chargez ou créez est stocké dans une Scene (un peu comme un contexte GL ou Warp3D ....)
La Scene comprend également une fenêtre Amiga et une bitmap Amiga qui est utilisé comme back buffer.
Donc la première étape pour démarrer un programme Microbe3D est d'ouvrir une Scene
Scene est alors nécessaire en tant que paramètre pour diverses fonctions Microbe3D
Mais certaines fonctions n'ont pas besoin de spécifier la Scene comme
U3D_Write(MyObject,"myobject.obj");
comme MyObject est déjà défini dans une Scene particulière
Object
Microbe3D utilise des objets 3D chargés à partir de fichiers .OBJ uniquement
Mais il y a plusieurs convertisseurs disponibles sur Internet qui pourront convertir différents formats vers le format .OBJ
Vous pouvez utiliser Blender pour créer ou importer/convertir/exporter des objets
Menu Blender: Fichier/Exporter/Wavefront (.OBJ)
Material
Microbe3D utilise des Matériaux 3D standards chargés à partir de fichiers .MTL
Vous pourrez donc avoir du cuivre, du marbre, du verre .... comme Matériaux.
Microbe3D ne peux pas manipuler directement ni créer des Matériaux.
Mais il suffit d'utiliser n'importe quelle application 3D (comme Blender) pour créer des Matériaux, puis les charger à partir du fichier .OBJ/.MTL
Group
Group est une liste de triangles qui utilisent un Matériau.
Un Group défini donc la partie d'un objet utilisant un Matériau particulier.
Microbe3D ne peux pas manipuler directement les Groups.
Mais il suffit d'utiliser n'importe quelle application 3D (comme Blender) d'y créer des Groups, puis les charger à partir du fichier .OBJ.
Light
Il y a 8 lumières dans la Scene qui peuvent être désactivées/activées/ modifiées comme vous voulez
L'éclairage dans Microbe3D suit (essentiellement) les règles OpenGL.
Instance
C'est quelque chose (Thing) qui est affiché sur la Scene et peut être déplacé/tourné/redimensionné.
Généralement les Instances affichent des objets
MyObject=U3D_Read(Scene,"eagle.obj"); /* chargé en mémoire */
Instance=U3D_AddInstance(Scene,MyObject,"myinstance"); /* affiché à l'écran */
Vous pouvez avoir plusieurs Instances d'un même objet: ainsi on peut afficher le même objet dans des tailles/positions différentes
Carte et Instances sont les seules choses vraiment affichées à l'écran dans une Scene
Map
Une carte est utilisée pour un jeu vidéo: cela défini une grille qui affiche plusieurs objets comme un jeu d'échecs
Une carte peut être 2D ou 3D
Une carte est remplie avec des Tiles
Carte et Instances sont les seules choses affichées dans une Scene
Tile
Est une case d'une Map qui contient juste un numéro (=TileNum) ou 0 si elle est vide
TileDef
Un TileDef défini ce qui sera affiché (=Object) si un Tile contient une valeur particulière (=TileNum)
Thing
Thing est un paramètre de fonction générique défini comme un APTR (pointeur void*)
Un pointeur d'adresse APTR (Adresse Pointer aussi nommé pointeur void*) designe une adresse mémoire quelconque où est stockée votre Thing.
Une fonction qui peut utiliser une Thing fonctionne avec un objet ou une Instance ou une Light, etc ..
Fonctions pour démarrer un programme/créer une Scene
APTR U3D_EasyOpenScene(UBYTE* name, UWORD width, UWORD height);
Crée une Scene facilement
Création de la Scene, de la fenêtre, de la bitmap (backbuffer) de la taille donnée
Scene = U3D_EasyOpenScene ("Mon premier programme Microbe3D", 320,240);
Attention si vous utilisez cette fonction alors Microbe3D gérera aussi les IDCMP messages de la fenêtre
Valeur de retour: une Scene ou NULL
APTR U3D_OpenScene(APTR win, APTR bm, UWORD x, UWORD y, UWORD width, UWORD height,ULONG flags);
Crée une Scene pour les spécialistes
Vous donnez une fenêtre Amiga (window) déjà ouverte et un bitmap Amiga comme backbuffer déjà créé
(width x height = largeur x hauteur)
Le Bitmap backbuffer sera copié en x y dans la fenêtre donnée
Attention si vous utilisez cette fonction alors Microbe3D ne gére pas la fenêtre : c'est à vous de la créer/gérer
Flags vaut 0 dans cette version
Valeur de retour: une Scene ou NULL
Fonctions pour remplir la Scene
APTR U3D_Read(APTR Scene, UBYTE* filename);
Lit le fichier Wavefront ( .OBJ) nommé filename lit aussi le fichier correspondant .MTL avec ses Matériaux
Valeur de retour: un Object ou NULL
APTR U3D_AddInstance(APTR ParentInstance, APTR Thing,UBYTE* name);
Ajoute une Instance nommée name dans la Scene
Thing est un Object ou une Map ou NULL
ParentInstance est la Scene
Valeur de retour: une Instance ou NULL
Fonctions pour modifier la Scene
void U3D_SetInstance(APTR Instance, APTR Thing, ULONG Material);
Modification d'une Instance existante
Affiche maintenant la Thing donnée avec ce Matériau qui sera utilisé pour afficher toute cette Instance
Permet donc de changer ce qu'affiche une Instance existante ou de modifier globalement son aspect.
Thing est un Object ou une Map ou NULL
Materiau est un des Matériaux existant
APTR U3D_SetLight(APTR Light, BOOL Enabled, float* Color);
Modifie ou active/désactive une lumière
Light est une des huit Lights numérotées de 1 à 8.
Si le parametre Light=Scene alors on modifie la couleur ambiente de toute la Scene et on active/desactive tout l'éclairage.
Enabled est TRUE/FALSE
Color est la couleur RGB de la lumière définie comme 3 floats
Valeur de retour: Le parametre Light ou NULL
APTR U3D_SetLightPlus(APTR Light,float SpotExponent,float SpotCutoff,float ConstantAttenuation,float LinearAttenuation,float QuadraticAttenuation)
Modifie les paramétres speciaux d'une lumière : fonctions à réserver aux specialistes.
Light une des huit Lights numérotées de 1 à 8.
SpotExponent,SpotCutoff,ConstantAttenuation,LinearAttenuation,QuadraticAttenu ation sont les mêmes que ceux de OpenGL
Valeur de retour: une Light (ou la Scene) ou NULL
Fonction permettant de dessiner une Scene
void U3D_DrawScene(APTR Scene);
Trace toutes les Instances et Maps définies dans une Scene: Trace Tout.
Fonction de suppression de Things/Fermeture du programme
void U3D_Delete(APTR Thing);
Efface & libère en mémoire la Thing donnée
Thing peut être Scene/Object/Instance/Light/Map
Object: le retire de la Scene et le libère en mémoire
Instance: le retire de la Scene et le libère en mémoire
Map: le retire de la Scene et le libère en mémoire
Light: juste la désactive
Scene: La Scene et tout le reste sont libérés en mémoire. Fenêtre et bitmap sont fermées/libérées.
Fonctions de modification de position/redimensionnement
void U3D_Translate(APTR Thing, float x, float y, float z,ULONG mode);
Translation de la Thing donnée
Thing peut être Object/Instance/Light
Objet: modifie l'objet original chargé (action destructrice)
Instance: modifie juste sa position actuelle
Light: modifie sa position
Pour un Object le mode est ignoré
Pour une Instance/Light si le mode est U3D_RESET alors les valeurs x y z remplacent totalement les anciens x y z de translation. Mais pour une Light prend aussi en compte la position par défaut (le défaut OpenGL)
Pour une Instance/Light si le mode est U3D_CHANGE alors les valeurs x y z s'ajoutent aux anciens x y z de translation.
void U3D_Rotate(APTR Thing, float x, float y, float z,ULONG mode);
Rotation de la Thing donnée
Thing peut être Object/Instance/Light
Objet: modifie l'objet original chargé (action destructrice)
Instance: modifie juste sa rotation actuelle
Light: modifie sa direction
Pour un Object le mode est ignoré
Pour une Instance/Light si le mode est U3D_RESET alors les valeurs x y z remplacent totalement les anciens x y z de rotation.Pour une Light prend aussi en compte la position par défaut (le défaut OpenGL)
Pour une Instance/Light si le mode est U3D_CHANGE alors les valeurs x y z s'ajoutent aux anciens x y z de rotation.
void U3D_Scale(APTR Thing, float x, float y, float z,ULONG mode);
Redimensionnement de la Thing donnée
Thing peut être Object/Instance
Objet: modifie l'objet original chargé (action destructrice)
Instance: modifie juste sa taille actuelle
Pour un Object le mode est ignoré
Pour une Instance si le mode est U3D_RESET alors les valeurs x y z remplacent totalement les anciens x y z de redimensionnement.
Pour une Instance si le mode est U3D_CHANGE alors les valeurs x y z se multiplient aux anciens x y z de redimensionnement.
Fonctions de modification de données d'objets
AVERTISSEMENT: Ces actions vont véritablement modifier l'objet chargé original (actions destructrices)
void U3D_ReverseWinding(APTR Object);
Inverse les faces: sens horaire ou antihoraire
void U3D_SetSpecialMaterial(APTR Object, APTR Material, APTR Material2, ULONG MatMode);
Défini un Matériau spécial dans cet Objet.
Material est un Matériau existant dans cet Objet.
Material2 est un Matériau existant dans cet Objet.
Pour U3D_TEXCUBIC/U3D_MATENVCUBE Material2 définit la première face d'un env-cube sinon mettre NULL
(Voir un exemple dans materials-list.mtl )
Pour U3D_MATBUMP Material2 définit le bump material de base
MatMode peut être
U3D_TEXLINEARX Fait un texturing linéaire selon l'axe x
U3D_TEXLINEARY Fait un texturing linéaire selon l'axe y
U3D_TEXLINEARZ Fait un texturing linéaire selon l'axe z
U3D_TEXCUBIC Fait un texturing sphérique
U3D_TEXSPHERIC Fait un texturing cube
U3D_MATENVCUBE Fait un cube mapping-environnement (dynamique)
U3D_MATTOON Fait un ombrage toon (dynamique)
U3D_MATBUMP Fait un bump mapping (dynamique)
void U3D_Weld(APTR Object, float WeldV, float WeldN, float WeldUV);
élimine (weld=souder) des sommets qui sont plus proches que la distance WeldV
Cela simplifie un objet par la suppression de sommets inutiles
Cela peut se faire avec les sommets et/ou les normales et/ou les valeurs UV
Principe: Pour chaque sommet si un sommet est plus proche que la distance WeldV à
partir d'un autre sommet alors garde le premier sommet et retire le deuxième sommet
Idem pour les normales de sommets avec WeldN
Idem pour les valeurs de texture UV avec WeldUV
void U3D_GridWeld(APTR Object, float GridV, float AngleN, float GridUV)
Identique à U3D_Weld, mais aligne d'abord les points existants sur une grille puis appele U3D_Weld()
GridV et GridUV sont les pas de la grille pour les valeurs des sommets et les valeurs de texture UV
AngleN est la résolution angulaire(degré) voulue pour les normales
AngleN génère un GridN = la distance minimale nécessaire pour représenter cet AngleN
(GridN = sin (AngleN* Pi/180.0);)
Typiquement pour enlever les points doubles qui ne sont pas visibles à l'écran on fera:
Scene = U3D_EasyOpenScene ("Mon premier programme Microbe3D", 320,240);
float PixelResolution = 1.0/(float) 320;
MyObject = U3D_Read (Scene, "myobject.obj"); /* chargé en mémoire* /
U3D_GridWeld (MyObject,PixelResolution.0.0.0.0);
void U3D_Unitize(APTR Object, float size);
Force l'objet à tenir dans un cube de dimension = size
Typiquement pour ajuster un objet dans l'écran donc de -1.0 à 1.0
U3D_Unitize (Object,2.0);
void U3D_Box(APTR Object, float x, float y, float z);
Comme U3D_Unitize () mais force l'objet à tenir dans une bo?te avec des dimensions x y z
Une dimension peut être 0.0 et ainsi rester inchangée
U3D_Box (Object,0.2,0.2,0.0); /* Taille de l'objet en x sera 0.2, en y sera 0.2, mais en z sera inchangée */
void U3D_SwapAxis(APTR Object, ULONG mode);
Permute toutes les valeurs des sommets
si mode=U3D_SWAPYZ alors les y et z sont permutés
si mode=U3D_SWAPXZ alors les x et z sont permutés
si mode=U3D_SWAPXY alors les x et y sont permutés
si mode=U3D_SWAPUV alors les u et v sont permutés
void U3D_ObjectNormals(APTR Object, float SmoothAngle);
Génére des normales pour l'objet permettant ainsi l'éclairage
si SmoothAngle = 0.0 alors génére juste une normale par triangle
si SmoothAngle > 0.0 alors génère une "normale de sommet" par sommet pour les faces dont AngleFaces < SmoothAngle
Donc permet l'éclairage Gouraud et des faces arrondies.
si SmoothAngle < 0.0 alors supprimera toutes les normales existantes et donc l'éclairage
Note: Dans cette version SmoothAngle est le même pour tout l'objet et non pas adapté à chaque Material
void U3D_Write(APTR Object, UBYTE* filename);
Enregistre l'objet comme un fichier .OBJ et un .MTL
Ne sauvegarde pas les images des textures
Fonctions d'interrogation
void U3D_Dimensions(APTR Object, Vertex3D *min,Vertex3D *max,Vertex3D *size);
Donne les dimensions de la Thing
Thing peut être Object/Groupe/Material
min->x contient le plus petit x de la Thing (idem pour min->y min->z)
max->x contient le plus grand x de la Thing (idem pour max->y max->z)
size->x = (max->x - min->x); (idem pour size->y size->z)
APTR U3D_Find (APTR BaseThing, ULONG type, UBYTE* name);
Retrouve le pointeur d'une chose existante à partir de son nom (name)
BaseThing peut être Scene/Object/Group/Instance c'est là où on cherche.
type est le nom du type de chose recherchée
Si BaseThing est une Scene alors type peut être U3D_OBJECT,U3D_INSTANCE,U3D_MAP,U3D_LIGHT
Si BaseThing est un Object alors type peut être U3D_MATERIAL,U3D_GROUP
Si BaseThing est un Group alors type peut être U3D_MATERIAL
Si BaseThing est une Instance alors type peut être U3D_THING
Object=U3D_Find (Scene,U3D_OBJECT, "teapot.obj");
RubyMaterial=U3D_Find (Object,U3D_MATERIAL, "mat_ruby_transp");
EnvCubeMaterial=U3D_Find (Object,U3D_MATERIAL, "mat_cubemapxpos");
U3D_SetSpecialMaterial(Object,RubyMaterial,EnvCubeMaterial,U3D_MATENVCUBE);< br />Valeur de retour: un Object/Instance/Map/Material/Group/Light/Vector3D/Thing ou NULL
APTR U3D_Get(APTR BaseThing, ULONG type, ULONG Tnum);
Retrouve le pointeur d'une chose existante à partir de son numéro (Tnum=Thing numéro)
Fonctionne comme U3D_Find()
Object=U3D_Find (Scene,U3D_OBJECT,3);
Note: Scene/U3D_MOUSEVECTOR renvoie un pointeur sur la position souris normalisée
Vertex3D* MouseVector;
MouseVector=U3D_Get(Scene,U3D_MOUSEVECTOR,0);
Si Tnum est supérieur ou égal au nombre de choses existantes renvoie NULL
Valeur de retour: un Object/Instance/Map/Material/Group/Light/Thing ou NULL
UBYTE* U3D_Name(APTR Thing);
Donne le nom d'une chose existante
Attention: Les noms font moins de 80 caractères maximum
Valeur de retour: un pointeur UBYTE* sur le nom ou NULL
LONG U3D_QueryValue(APTR BaseThing,ULONG type)
Renvoie la valeur de différentes variables de la Scene
Comme le nombre de triangles,points,etc d'un Objet,comme le taux FPS de la Scene (Frames Per Second), comme la position souris,etc...
Les champs interrogeables sont
Pour obtenir leur nombre:
U3D_INSTANCE
U3D_OBJECT
U3D_MATERIAL
U3D_GROUP
U3D_TRIANGLE
U3D_VERTEX
U3D_UV
U3D_VNORMAL
U3D_FNORMAL
U3D_LIGHT
U3D_MAP
U3D_TILEDEF
U3D_TILE
Pour obtenir la rapidité
U3D_FPS Frames per second (Vitesse d'affichage)
U3D_FPS50 Frames per second en moyenne sur 50 frames
U3D_TRISDONE Triangles tracés par seconde
U3D_TRIS50 Triangles tracés par seconde moyenne sur 50 frames
U3D_TPF Time per Frame en millisecondes (Vitesse d'affichage)
U3D_TPF50Time per Frame en millisecondes (Vitesse d'affichage) en moyenne sur 50 frames */
Pour des infos
U3D_TIME Temps écoulé compté en 1/25éme seconde
U3D_MEMSIZE Mémoire utilisée
U3D_VERSION version de Microbe3D
Si vous avez utilisé U3D_EasyOpenScene() ces champs sont remplis automatiquement
U3D_MOUSEX U3D_MOUSEY Position souris en pixel
U3D_MOUSEBUTTONS Boutons souris
U3D_VANILLAKEY Touche clavier
U3D_MENUCOMMAND Menu command du menu sélectionné
U3D_GADGETID Gadget ID du gadget sélectionné
voir dans Microbe3D.h
Fonctions pour Map & Tiles
APTR U3D_AddMap(APTR Scene,UBYTE *name,Vertex3D *TileSize,ULONG width,ULONG height,ULONG depth);
Crée une nouvelle carte pour un jeu
TileSize est la taille de chaque Tile de la Map
width,height,depth sont les dimensions de la Map en nombre de Tile
Une Map 2D (comme un jeu d'échecs) a une height de 1
ChessMap=U3D_AddMap(Scene,8,1,8);
Carte et Instances sont les seules Things affichées
Valeur de retour: une Map ou NULL
void U3D_SetTileDef(APTR Map, ULONG TileNum, APTR Thing);
Dans une carte défini quel objet sera utilisé pour représenter un Tile pour un TileNum donné.
BlackSquareObject=U3D_Read(Scene,"MyBlackSquare.obj");
WhiteSquareObject=U3D_Read(Scene,"MyWhiteSquare.obj");
U3D_SetTileDef(ChessMap,1,BlackSquareObject);
U3D_SetTileDef(ChessMap,2,WhiteSquareObject);
REMARQUE: TileNum ne peux pas être égal à 0 puisque cette valeur est réservé pour des cases(Tile) vides
void U3D_SetTile(APTR Map, ULONG x, ULONG y, ULONG z, ULONG TileNum);
A une position donnée dans la carte défini le Tile
for(i=0;i<8;i++)
for(j=0;j<8;j++)
{
if((i+j) % 2)
U3D_SetTile(Map,i,0,j,1);
else
U3D_SetTile(Map,i,0,j,2);
}
ULONG U3D_GetTile(APTR Map, ULONG x, ULONG y, ULONG z);
A une position donnée dans la carte lire le Tile
TileNum=U3D_GetTile(ChessMap,4,0,5);
if(TileNum=1)
printf("Is black square\n");
if(TileNum=2)
printf("Is white square\n");
Valeur de retour: un TileNum ou 0
Fonction de création d'objets à partir de zéro
NOTE: Habituellement vous n'avez pas besoin de ces fonctions comme des objets sont chargés à partir de fichier .OBJ.
Ces fonctions ne servent qu'à créer des objets à partir de zéro pour les codeurs spécialistes en 3D.
ATTENTION: vous ne pouvez pas modifier un objet chargé à partir d'un fichier OBJ avec ces fonctions.
APTR U3D_AddObject(APTR Scene, UBYTE* name,ULONG Pnb,ULONG MATnb);
Crée un nouvel objet vide nommé name dans cette Scene
Cet objet aura Pnb points (Pnb=Points nombre)
Cet objet aura MATnb materiaux (MATnb=Materiaux nombre) ces Materiaux sont définis par défaut comme des niveaux de gris
La création d'un cube demande 6 carrés = 12 triangles = 36 points
CubeObjet=U3D_AddObject(Scene,"cube",36,1);
Note: une fois l'objet fini U3D_Weld() pourra supprimer tous les points en doublons
Valeur de retour: un Object ou NULL
APTR U3D_AddGroup(APTR Object, UBYTE* name,APTR Material);
Crée un nouveau Groupe vide nommé name dans cet Objet
Ce Groupe utilisera le materiau Material et contiendra donc toutes les faces qui utilisent ce Matériau
void U3D_AddFace(APTR Object);
Crée une nouvelle face vide dans cet Objet/Groupe
void U3D_AddPoint(APTR Object, Vertex3D* V, Vertex3D* VN, Uv3D* UV);
Crée un nouveau point dans cet Objet/Groupe/Face
V contient les valeurs x y z du sommet
VN contient les valeurs x y z de la "normale de sommet"
UV contient les valeurs u v de texturing
Remarque: Si vous n'avez pas de valeurs VN et/ou de valeurs UV alors mettre ces pointeurs à NULL
Parametres de fonctions
voir dans Microbe3D.h
Cet article provient de Le site des utilisateurs francophones actuels et futurs d'AmigaOS 4.x
https://amiga-ng.org/viewtopic.php?topic=1523&forum=14