Comme vous le savez mon anglais est très mauvais
Comme vous le savez aussi je bosse toujours sur ma lib Microbe3D et là j'ai traduis sa doc en anglais....
( Pour ceux qui connaissent pas Microbe3D vidéo ici
http://www.youtube.com/watch?v=2OC9dQoTXWs
)
Quelqu'un pourrais relire/corriger ma doc ci dessous ?
GRANDS MERCIS D'AVANCE
===============================================


Microbe3D: Micro 3D Engine for Wavefront .OBJ files using Warp3D
Microbe3D.library: Alain Thellier - Paris - FRANCE - 2011 to 2013

Why Microbe3D?
Microbe3D is a small engine that displays directly Wavefront .OBJ 3D files
MICROBE3D means "MICRo. OBj Engine for warp3D"

The general philosophy is "Keep it simple and make it simpler"
0) Microbe 3D is fast and beautiful
1) No need to know hundreds of functions as OpenGL
2) No need to try to understand how may work Warp3D
3) No need to set lots of "States" to obtain a particular effect
4) OpenGL is "drawing" oriented : Permanently you draw faces, points, colors, etc. ..
But Microbe3D is 3D-Object oriented : just load the 3D Objects in the Scene. Then draw the entire Scene with a single function
5) If Microbe3D contains 40 functions so my goal is "Can it be done with 35 functions to make it easier?"
6) So when a function does something similar to another, I try to make a generic function that can handle different "Things"
7) No need to know what you are working: all structures are private. The programmer only handles generic pointers (APTR = memory address)
8) When you call a function with a pointer to a "Thing", then automatically Microbe3D guess what this "Thing" is (Object, Scene, Light, Instance)
9) Microbe3D is 3D-Object oriented you do not draw or build your 3D Objects in Microbe3D = just create them with your favorite 3D applications (like Blender)
Then export as .OBJ. .MTL JPG
[Blender Menu : File/Export/Wavefront(.OBJ)]
10) Now (March 2013) Microbe3D has 35 functions, but in fact you need less than 10 Microbe3D functions to make a 3D program that works
11) With Microbe3D you can easily add a moving 3D-Object (rotating logo,etc...) to your Amiga applications
12) But Microbe3D is still a small 3D engine so do not expect to create "Quake" with it ;-)


First Microbe3D program

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;

}



Tutorial

Scene
Everything you create is loaded or stored in a Scene (Something like a GL context or Warp3D context ....)
The Scene also !!!include!!!s an Amiga-window and an Amiga-bitmap used as a back buffer.
So the first step to start a program is to open a Microbe3D Scene
Scene is necessary as a parameter for various Microbe3D functions
But some functions do not need to specify the Scene like
U3D_Write (MyObject, "myObject.obj");
as MyObject is already defined in a particular Scene

Object
Microbe3D uses 3D Objects loaded from .OBJ files only
But there are many converters available on the Internet that can convert different 3D formats to the .OBJ format
You can use Blender to create or import/convert/export Objects
Blender menu: File/Export/Wavefront (.OBJ)

Material
Microbe3D uses standard 3D Materials loaded from .MTL files
So you can have Materials like copper, marble,glass .... .
Microbe3D cant directly manipulate nor create materials.
But just use any 3D application (such as Blender) to create materials and then load them from a .MTL file

Group
Group is a list of triangles using a material.
So a Group define the portion of an Object using a special material.
Microbe3D can not directly manipulate Groups.
But just use any 3D application (such as Blender) to create Groups, and then load them from the .OBJ file

Light
There are 8 lights in the Scene that can be disabled/enabled/modified as you want
The lighting in Microbe3D follows (mostly) the OpenGL rules .

Instance
This is something (Thing) that is displayed on the Scene and can be moved/rotated/scaled.
Instances usually display Objects
MyObject = U3D_Read (Scene, "eagle.obj") /* loaded into memory * /
Instance = U3D_AddInstance (Scene, MyObject, "MyInstance") /* on the screen * /
You can have multiple Instances of the same Object: so we can display the same Object in different sizes/different positions
Map and Instance are the only things displayed in a Scene

Map
Map is used for a video game: it defined a grid that displays several Objects like a chess game
A Map can be 2D or 3D
A Map is filled with Tiles
Map and Instance are the only things displayed in a Scene

Tile
Is a case of a Map that contains just a number (=TileNum) or 0 if it is empty

TileDef
TileDef define what will be displayed (= Object) if a tile contains a particular value (= TileNum)
Thing
Thing is a function parameter defined as a generic APTR (void* pointer)
This is the address pointer (APTR also called void* pointer) that store your Thing.
A function that use a Thing will works with an Object or Instance or Light, etc. ..


Functions to start a program/create a Scene

APTR U3D_EasyOpenScene(UBYTE* name, UWORD width, UWORD height);
Easily create a Scene
Create the window for the Scene and the bitmap (backbuffer) of the given size
Scene = U3D_EasyOpenScene ("My first Microbe3D program ", 320,240);
Be careful : if you use this function Microbe3D will also manage window's IDCMP messages
Return value: a Scene or NULL

APTR U3D_OpenScene(APTR win, APTR bm, UWORD x, UWORD y, UWORD width, UWORD height,ULONG flags);
Creates a Scene for specialists
You give an Amiga window (window) already opened and an already created Amiga bitmap as backbuffer
(width x height = bitmap size)
The backbuffer bitmap will be copied in the given window at x y
Be careful if you use this function then Microbe3D wont manage window's IDCMP messages. It is up to you to create/manage IDCMP messages
Flags is 0 for this version.
Return value: a Scene or NULL


Functions to fill the Scene

APTR U3D_Read(APTR Scene, UBYTE* filename);
Reads the Wavefront file (.OBJ) named filename also reads the file. MTL with Materials. Now also works for .GEO file
Return value: an Object or NULL

APTR U3D_AddInstance(APTR ParentInstance, APTR Thing,UBYTE* name);
Adds an Instance named "name" in the Scene
Thing is an Object or Map or NULL
ParentInstance is the Scene or an other Instance
Return Value: An Instance or NULL


Functions to modify the Scene

void U3D_SetInstance(APTR Instance, APTR Thing, ULONG Material);
Modify an existing Instance
The Instance will now display this Thing. This material will be used to display all this Instance
So change what is displayed by an Instance or modify his appearance.
Thing is an Object or Map or NULL
Material is an existing Material or NULL

APTR U3D_SetLight(APTR Light, BOOL Enabled, float* Color);
Changes or activates/desactivates a light
Light is an existing Light. The Scene got eight Lights numbered 1 to 8.
If parameter Light=Scene then we modify the ambient color of the entire Scene and enable/disable all lighting.Enabled is TRUE/FALSE
Color is light color defined as 3 RGB floats
Return Value: The Light parameter or NULL

APTR U3D_SetLightPlus(APTR Light,float SpotExponent,float SpotCutoff,float ConstantAttenuation,float LinearAttenuation,float QuadraticAttenuation)
Modifies the parameters of a special light: functions reserved for specialists.
Light is an existing Light. The Scene got eight Lights numbered 1 to 8.
SpotExponent, SpotCutoff, ConstantAttenuation, LinearAttenuation, QuadraticAttenuation are the same as OpenGL
Return Value: A Light or NULL

Function to draw a Scene

void U3D_DrawScene(APTR Scene);
Draw all Instances & Maps defined in a Scene: Draw all.

Function that delete Things/Close program

void U3D_Delete(APTR Thing);
For a given Thing clear away & free the used memory
Thing may be Scene/Object/Instance/Light/Map
Object: removed from the Scene and freed from memory
Instance: removed from the Scene and freed from memory
Map: removed from the Scene and freed from memory
Light: just disable
Scene: The Scene and all are removed and free all the used memory. Window and bitmap are closed/freed.


Functions to modify position/scale


void U3D_Translate(APTR Thing, float x, float y, float z,ULONG mode);
Translation of the given Thing
Thing can be Object/Instance/Light
Object: modifies the original loaded Object (destructive action)
Instance: just change its current position
Light: changes its position
For Object the mode is ignored
For Instance/Light if the mode is U3D_RESET then xyz values completely replace the old translation. But for Light also takes into account the default position (the OpenGL default position )
For Instance/Light if the mode is U3D_CHANGE then xyz values are added to the old xyz translation.

void U3D_Rotate(APTR Thing, float x, float y, float z,ULONG mode);
Rotation of the given Thing
Thing can be Object/Instance/Light
Object: modifies the original loaded Object (destructive action)
Instance: just change its current rotation
Light: changes its direction
For Object the mode is ignored
For Instance/Light if the mode is U3D_RESET then xyz values completely replace the old rotation. But for Light also takes into account the default position (the OpenGL default position )
For Instance/Light if the mode is U3D_CHANGE then xyz values are added to the old xyz rotation.

void U3D_Scale(APTR Thing, float x, float y, float z,ULONG mode);
Resizing of the given Thing
Thing can be Object/Instance
Object: modifies the original loaded Object (destructive action)
Instance: just change its current size
For Object the mode is ignored
For Instance if the mode is U3D_RESET then xyz values completely replace the old xyz scale.
For Instance if the mode is U3D_CHANGE then xyz values are multiplied to the old xyz scale.

Fonctions that modify Object data
WARNING: These actions will truly change the original loaded Object (destructive action)

void U3D_ReverseWinding(APTR Object);
Chnage hidden face side: clockwise or counterclockwise

void U3D_SetSpecialMaterial(APTR Object, APTR Material, APTR Material2, ULONG MatMode);
Defined a special material in this Object.
Material is a Material that exists in that Object.
Material2 is a Material that exists in that Object.
Material2 for U3D_TEXCUBIC/U3D_MATENVCUBE is the first face that defines a cube-env otherwise is NULL
(See an example in materials-list.mtl)
For U3D_MATBUMP Material2 defines the bump material
MatMode can be
U3D_TEXLINEARX Makes a linear texturing among x axis
U3D_TEXLINEARY Makes a linear texturing among y axis
U3D_TEXLINEARZ Makes a linear texturing among z axis
U3D_TEXCUBIC Makes a spherical texturing
U3D_TEXSPHERIC Makes a cube texturing
U3D_MATENVCUBE Makes an environment cube-mapping(dynamic)
U3D_MATTOON Makes a toon shading (dynamic)
U3D_MATBUMP Makes a bump Mapping (dynamic)

void U3D_Weld(APTR Object, float WeldV, float WeldN, float WeldUV);
Eliminate (weld) vertices that are closer than the WeldV distance
This simplifies an Object by removing unnecessary vertices
This can be done with the vertices and/or normal and/or UV values
Principle: For each vertex if a vertex is closer than the distance to WeldV
from another vertex then the first vertex is keeped and the second vertex removed
Ditto for vertex-normals with WeldN
Ditto for the UV texture values with WeldUV

void U3D_GridWeld(APTR Object, float GridV, float AngleN, float GridUV)
Same as U3D_Weld same but first aligns existing points on a grid then call U3D_Weld()
GridV GridUV are the grid steps for the vertices values and UV texture values
AngleN is the required angular resolution(as degree) for normals
AngleN generates GridN = the minimum distance required to represent this AngleN
(GridN = sin (AngleN Pi/180.0 *) ;)
Typically for removing double points which are not visible on the screen will be:
Scene = U3D_EasyOpenScene ("My first program Microbe3D", 320,240);
float PixelResolution = 1.0/(float) 320;
MyObject = U3D_Read (Scene, "myObject.obj"); /* loaded into memory * /
U3D_GridWeld (MyObject, PixelResolution,0.0.0.0);

void U3D_Unitize(APTR Object, float size);
Force the Object to fit into a cube. Cube dimension is the size
Typically in order to adjust an Object to the screen (so -1.0 to 1.0) we do
U3D_Unitize (Object, 2.0);

void U3D_Box(APTR Object, float x, float y, float z);
As U3D_Unitize() but forces the Object to fit in a box with dimensions x y z
A dimension can be 0.0 and thus remain unchanged
U3D_Box (Object, 0.2,0.2,0.0); /* Size of the Object x is 0.2, will be in 0.2, but z is unchanged * /

void U3D_SwapAxis(APTR Object, ULONG mode);
Permute all values of the vertices
if mode = U3D_SWAPYZ then y and z are swapped
if mode = U3D_SWAPXZ then x and z are swapped
if mode = U3D_SWAPXY then x and y are swapped
if mode = U3D_SWAPUV then u and v are swapped


void U3D_ObjectNormals(APTR Object, float SmoothAngle);
Generate normals for the Object so allowing lighting
if SmoothAngle = 0.0 then generates just a normal per triangle
if SmoothAngle > 0.0 then generates a "normal vertex" for the faces if AngleFacesSo allow Gouraud lighting and rounded faces.
if SmoothAngle < 0.0 then delete all existing normals and therefore all lighting
Note: In this version SmoothAngle is the same for the whole Object and not adapted to each Material


void U3D_Write(APTR Object, UBYTE* filename);
Saves the Object as a .OBJ and. MTL files
Do not save textures pictures

Query functions

void U3D_Dimensions(APTR Object, Vertex3D *min,Vertex3D *max,Vertex3D *size);
Gives the dimensions of the Thing
Thing can be Object/Group/Material
min->x contain the smallest x value in the Thing (ditto for min->y min->z)
min->x contain the biggest x value in the Thing (ditto for max->y max->z)
size->x = (max->x - min->x); (ditto for size->y size->z)


APTR U3D_Find (APTR BaseThing, ULONG type, UBYTE* name);
Retrieve the pointer to an existing Thing from its name
BaseThing can be Scene/Object/Group/Instance. BaseThing is where we seek.
type is the name of the desired type of thing
If BaseThing is Scene then type can be U3D_OBJECT,U3D_INSTANCE,U3D_MAP,U3D_LIGHT
If BaseThing is an Object then type can be U3D_MATERIAL,U3D_GROUP
If BaseThing is a Group then type can be U3D_MATERIAL
If BaseThing is an Instance then type can be 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);
Return Value: A NULL or an Object/Instance/Map/Material/Group/Light/Vector3D/Thing

APTR U3D_Get(APTR BaseThing, ULONG type, ULONG Tnum);
Find the pointer on a existing Thing from their number (Tnum = Thing number)
Works as U3D_Find()
Object=U3D_Find (Scene,U3D_OBJECT,3);
Note: Scene/U3D_MOUSEVECTOR returns a pointer to the normalized mouse position
Vertex3D* MouseVector;
MouseVector=U3D_Get(Scene,U3D_MOUSEVECTOR,0);
If Tnum is greater than or equal to the number of existing Things returns NULL
Return Value: An Object/Instance/Map/Material/Group/Light/Thing or NULL

UBYTE* U3D_Name(APTR Thing);
Gives the name of an existing thing
Warning: The names are less than 80 characters
Return value: an *UBYTE pointer to the name or NULL

LONG U3D_QueryValue(APTR BaseThing,ULONG type)
Returns the value of different variables in the Scene
As the number of triangles, points, etc. of an Object, as the FPS rate of Scene (Frames Per Second) as the mouse position, etc ...
Searchable fields are :

To obtain their count:
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

For speed
U3D_FPS Frames per second (Speed display)
U3D_FPS50 Frames per second (average on 50 frames)
U3D_TRISDONE Triangles drawn per second
U3D_TRIS50 Triangles drawn per second (average on 50 frames)
U3D_TPF Time per frame in milliseconds (Display speed)
U3D_TPF50 Time per frame in milliseconds (Display speed) (average on 50 frames)

For information
U3D_TIME Elapsed time counted as 1/25th second
U3D_MEMSIZE Memory usage
U3D_VERSION Microbe3D version

If you used U3D_EasyOpenScene() then those fields are automatically filled
U3D_MOUSEX U3D_MOUSEY mouse position in pixels
U3D_MOUSEBUTTONS Mouse buttons
U3D_VANILLAKEY Keyboard key
U3D_MENUCOMMAND Menu of the selected menu command
U3D_GADGETID Gadget selected Id
see Microbe3D.h

Functions for Map & Tiles

APTR U3D_AddMap(APTR Scene,UBYTE *name,Vertex3D *TileSize,ULONG width,ULONG height,ULONG depth);
Creates a new Map for a game
TileSize is the size for each Tile in the Map
width, height, depth are the Map dimensions as Tiles counts
A 2D Map (like a chess game) has a height of 1
ChessMap=U3D_AddMap(Scene,8,1,8);
Map and Instance are the only things displayed in a Scene
Return value: A Map or NULL

void U3D_SetTileDef(APTR Map, ULONG TileNum, APTR Thing);
In a Map define what will be used to represent a Tile for a given TileNum.
BlackSquareObject=U3D_Read(Scene,"MyBlackSquare.obj");
WhiteSquareObject=U3D_Read(Scene,"MyWhiteSquare.obj");
U3D_SetTileDef(ChessMap,1,BlackSquareObject);
U3D_SetTileDef(ChessMap,2,WhiteSquareObject);
NOTE: TileNum can not be 0 since this value is reserved for empty Tiles

void U3D_SetTile(APTR Map, ULONG x, ULONG y, ULONG z, ULONG TileNum);
To a given position in the Map define the 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);
To a given position in the Map read the Tile
TileNum=U3D_GetTile(ChessMap,4,0,5);
if(TileNum=1)
printf("Is black square\n");
if(TileNum=2)
printf("Is white square\n");
Return Value: A TileNum or 0

Function to create Objects from scratch
NOTE: Usually you do not need these functions as Objects are loaded from .OBJ file
These functions serve only to create Objects from scratch for 3D expert-coders.
CAUTION: You can not modify an Object loaded from an OBJ file with these functions.

APTR U3D_AddObject(APTR Scene, UBYTE* name,ULONG Pnb,ULONG MATnb);
Creates a new empty Object named name in the Scene
This Object will have Pnb points (Pnb=Points count)
This Object will have MATnb materials (MATnb=Materials count). The Materials are defined by default as greyscale
Creating a cube request 6 squares = 12 triangles = 36 points
CubeObjet=U3D_AddObject(Scene,"cube",36,1);
Note: Once the Object is finished U3D_Weld() will remove all duplicates points
Return value: an Object or NULL

APTR U3D_AddGroup(APTR Object, UBYTE* name,APTR Material);
Creates a new empty Group named name in the Object
This group will use the material Material and therefore contain all faces that use this material

void U3D_AddFace(APTR Object);
Creates a new empty Face in this Object/Group

void U3D_AddPoint(APTR Object, Vertex3D* V, Vertex3D* VN, Uv3D* UV);
Creates a new Point in the Object/Group/Face
V contains the x y z vertex values
VN contains the x y z vertex-normal values
UV contains the u v texturing values
Note: If you dont have values for VN and/or UV then set those pointers to NULL

Function parameters
see Microbe3D.h

Message édité par : Elwood / 08-04-2013 22:16

La doc en Français pour comparaison:
=============================================

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,QuadraticAttenuation 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);
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

Si je comprends bien M3D fait comme W3D. Si c'est le cas, je te conseil de le préciser dans la doc. ça permet de bien comprendre ce que sait en peu d'explications :-)

Je te conseil l'utilisation de Entité (Entity) au lieu de Chose. Je trouve que ça passe mieux.

Malheureusement je n'ai pas le temps. J'espère que quelqu'un pourra vérifier ta traduction...

Hello
merci du retour
>Je te conseil l'utilisation de Entité (Entity) au lieu de Chose
C'est vrai que Entity est mieux en anglais par contre en français ça veut pas dire grand chose à par les "Entités Biologique Extra-terrestre" de Mulder :-P
En plus comme c'est un nom de paramétre j'ai vraiment pas envie de le modifier dans tout les "!include!" que je viens juste de finir ==> je garde Chose/Thing


>Si je comprends bien M3D fait comme W3D.
ouh la la ....
Alors là je me dis que j'ai du bien mal expliquer si c'est ce qu'on peut croire :-/
non non non Microbe3D ne fait pas comme Warp3D ou MiniGL(=Mesa=OpenGL)

1) Il fait mieux cad que c'est une bibliotheque de haut niveau contrairement à Warp3D avec peu de fonctions qui font beaucoup de boulot (voir exemple demo-simpler.c ci dessous)

2) Avec Warp3D (mais aussi MiniGL & co) pour tracer un objet il faut le tracer triangle par triangle (ou au mieux par gros paquets de triangles)
,en sélectionnant la texture, le mode de transparence,etc.... c'est une bibliotheque orientée tracage
Alors que là on charge un ou plusieurs fichiers d'objets 3D et après Microbe3D se charge de tout le tracage en un seule instruction
C'est un peu comme ce que fait la datatype.library pour les images = tout le boulot

3) La différence entre MiniGL et Warp3D c'est le Transformation & Lighting
Pour les deux on trace on trace des triangles mais MiniGL les met en plus dans la position que l'on veut (cad change le point de vue de la scene) et en plus leur applique un éclairage (cad colorie leurs sommets selon l'influence des lampes)
==> Le Transformation & Lighting est implémenté dans Microbe3D aussi :-)

Evidemment on a moins de controle sur les effets "inhabituels" qu'avec MiniGL et Warp3D par contre pour afficher des objets/matériaux "classiques" y a pas plus simple (pas besoin de centaines de lignes pour à peine commencer à tracer comme avec Warp3D)

Alain

/* Microbe3D: micro .obj 3D engine for Wavefront.OBJ files that use Warp3D */
/* Microbe3D library: Alain THELLIER - Paris - FRANCE - July 2011 to 2013 */
/* Microbe3D is small 3D engine that display directly 3D Wavefront .obj files */
/* It is maded as a library for programmers */
/* If you are a programmer and you want to have a nice 3D object(animated logo) */
/* in your Amiga app then Microbe3D is done for you */

/* This file contains a demo for Microbe3D : a simple rotating logo with env-mapping*/


#!!include!! /proto/Microbe3D.h>
struct Library* Microbe3DBase=NULL;
#ifdef OS4
struct Microbe3DIFace* IMicrobe3D =NULL;
#endif

/*=================================================================*/
int main(int argc, char *argv[])
{
APTR Scene;
APTR Object;
APTR Instance;
APTR Material;
APTR Material2;
ULONG VanillaKey;

Microbe3DBase = OpenLibrary("Microbe3D.library",28);
if (Microbe3DBase==NULL)
goto panic;
#ifdef OS4
IMicrobe3D = (struct Microbe3DIFace*)GetInterface((struct Library *)Microbe3DBase, "main", 1, NULL);
if (IMicrobe3D==NULL) return(FALSE);
#endif

Scene =U3D_EasyOpenScene("Amiga Logo",480,480); /* open a scene in 480x480 pixels window */

Object=U3D_Read(Scene,"data/AmiLogo.obj"); /* load a 3D object */
if(Object==NULL) goto panic; /* if not loaded then exit */

U3D_Unitize(Object,2.0); /* fit to screen (ie -1.0 +1.0) */
U3D_Normals(Object,0.0); /* do simple face normals */
U3D_GridWeld(Object,(1.0/500.0),0.001,0.001); /* will remove the double points not visible on screen */

Material =U3D_Find(Object,U3D_MATERIAL,"mat_white_plastic"); /* obtain current logo's material */
Material2=U3D_Find(Object,U3D_MATERIAL,"mat_cubemapxpos"); /* find the env mapping cube called "mat_cubemapxpos" */
U3D_SetSpecialMaterial(Object,Material,Material2,U3D_MATENVCUBE); /* apply cub env mapping */

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 */
#ifdef OS4
if(IMicrobe3D) DropInterface((struct Interface*)IMicrobe3D );
#endif
if(Microbe3DBase) CloseLibrary(Microbe3DBase);
return 0;

}
/*==================================================================================*/







Message édité par : thellier / 09-04-2013 10:35

Dans ma question "M3D fait comme W3D" je voulais dire "si on utilise M3D alors qu'on a pas W3D installé, ça fonctionne", donc M3D remplace W3D.

Non plus ;-P

Microbe3D utilise directement Warp3D donc ça risque pas de fonctionner non plus....

Evidemment Microbe3D peut utiliser WaZp3D mais avec les mêmes problèmes que d'habitude (cad pas de Zbuffer en mode Composition)

Alain

Désolé Alain,

je ne peux pas t'aider (tu as déjà du constater que moi et l'anglais...)
mais j'ai lu ta doc en français et je trouve qu'elle est bien expliquée !

Par contre, par curiosité et pour envisager l'application de Microbe3D, la fonction

U3D_OpenScene(win,bm...) permet de placer une scéne sur n'importe quelle fenêtre ?

Par exemple, si je passe un pointeur sur une fenêtre MUI à U3D_OpenScene,
je pourrais créér une Scene et ensuite y placer un objet par U3D_Read / U3D_AddInstance pour future action par exemple U3D_Rotate ou U3D_Box ?

C'est cela ?

Et si oui, késako que "bitmap Amiga comme backbuffer" dans U3D_OpenScene ?

Microbe3D pour la 3D
et AmiDarkEngine pour la 2D...

Bravo :=!

Dommage qu'il manque Warp3D pour le plein support de ton microbe3D sur RadeonHD...

Ah ok, donc c'est une couche par dessus W3D. Ce qui permet de simplifier l'utilisation de la 3D. Soit c'est moi, soit c'est pas clair dans ta doc, soit les deux :-)

@Elwood
>Microbe3D est une couche par dessus Warp3D. Ce qui permet de simplifier l'utilisation de la 3D
Oui ç'est ça :-)
Mais tu fais bien de me faire la remarque : je me rends compte alors que c'est pas clair

@zzd10h
>U3D_OpenScene(win,bm...) permet de placer une scéne sur n'importe quelle fenêtre ?
C'est le but mais je t'avouerai que j'ai pas encore fait de démo utilisant cette fonction
Pour l'instant j'ai 7 démos : la plus compléte est le viewer déjà sur Aminet, la plus simple est le listing ci dessus qui fais juste tourner le logo Amiga

>Par exemple, si je passe un pointeur sur une fenêtre MUI à U3D_OpenScene,
je pourrais créér une Scene et ensuite y placer un objet par U3D_Read / U3D_AddInstance pour future action par exemple U3D_Rotate ou U3D_Box ?
>C'est cela ?
Tout à fait :-)
T'as raison ma doc en français doit être claire car t'as tout compris :-)

>Et si oui, késako que "bitmap Amiga comme backbuffer" dans U3D_OpenScene ?
c'est du double buffering en fait Microbe3D (cad U3D_Draw) trace toute la 3D dans une bitmap pas visible puis fait un BltBitMapRastPort de la bitmap dans la fenêtre à l'endroit x y voulu
C'est comme si on générait une image 2D dans une bitmap et l'affichait à un endroit donné dans la fenêtre : en ce sens c'est très similaire aux datatypes qui générent des images dans une bitmap

Une autre chose peut être peu claire dans la doc : Les Instances se comportent en fait comme des axes mécaniques (ou des articulations).
Si un objet (ou une map) est accroché à une Instance alors l'Instance est visible (exemple bras de robot)
Mais sinon on peut juste mettre des Instance accrochées les unes aux autres de manière hierarchiques (la plupart sans Objet3D) juste pour créer un mouvement plus complexe
Après les 3 actions (U3D_Rotate/Translate/Scale) ne font que remuer ces axes

Actuellement Microbe3D.library 68k et ppc sont compilées ainsi que les 7 exemples :-)
Mais les exemples montrent des bugs ... alors je finis le nettoyage ... ça devrait plus être trop long ... le plus dur est passé

Je suis très preneur de ta part d'un exemple utilisant MUI + U3D_OpenScene()


Alain

Pas de pb et avec plaisir pour l'exemple MUI.

Dis-moi ou je peux trouver les !include!s et un OBJ et j'essaierais.

je t'envoie mon @ mail par MP

A+
Guillaume