jak używać marzipana???

[GMcliker]

witam

otóż mam taki problem nie wiem jak zrobić grafikę 3d w gm. używam blendera.

proszę o wyjaśnienie krok po kroku

pozdro

[Tomek_K]

Masz krok po kroku a co tam :thumbsup: :D sory że po angielsku ale niechce mi sie tlumaczyc

 

 

 

Going to 3D mode

 

If you want to use 3D mode you first need to set Game Maker in 3D mode. You can later switch back to 2D mode if you want. The following two functions exist for this.

 

d3d_start() Start using 3D mode.

d3d_end() Stop using 3D mode.

 

Note that all functions related to 3D mode start with d3d_.

 

Starting 3D mode will result in the following changes. First of all hidden surface removal is switched on (using a 16-bit z-buffer). This means that for each pixel on the screen only the drawing with the smallest z-value (= depth value) is drawn. If instances have the same depth it is unclear what will happen and you can get ugly effects. Make sure instances that might overlap do not have the same depth value!

 

Secondly, the normal orthographic projection is replaced by a perspective one. This means the following. Normally the size of instances on the screen is independent on its depth. With a perspective projection instances that have a greater depth will appear smaller. When the depth is 0 it is equal to the old size (unless you change the projection; see below). The viewpoint for the camera is placed at a distance above the room. (This distance is equal to the width of the room; that gives a reasonable default projection.) Only instances in front of the camera are drawn. So don't use instances with a depth smaller than 0 (or at least not smaller than -w where w is the width of the room or the view).

 

Thirdly, the vertical y-coordinate is reversed. While normally the (0,0) position is at the top-left of the view, in 3D modo the (0,0) position is at the bottom-left position, as is normal for 3-dimensional views.

 

You can actually switch hidden surface remove and perspective projection on or off using the following functions.

 

 

d3d_set_hidden(enable) Enables hidden surface removal (true) or disables it (false).

d3d_set_perspective(enable) Enables the use of a perspective projection (true) or disables it (false).

 

 

Easy drawing

 

Once 3D mode has been switched on you can use Game Maker as you are used to it (except for the remarks made at the beginning). Only objects will appear in different sizes based on their depth setting. You can even use views. One additional function can be useful. If you draw a number of things in a piece of code you might want to change the depth value between the primitives you draw. For this you use:

 

d3d_set_depth(depth) Sets the depth used for drawing.

 

Note that at the moment a new instance is drawn the depth is again set to the depth of that instance.

 

 

 

Drawing polygons in 3D

 

 

The problem with drawing in the old way is that a sprite or polygon always lies in the xy-plane, that is, all corners have the same depth. For true 3D you want to be able to have vertices at different depths. From this moment on we will talk about z-coordinate rather than depth. So we want to specify coordinates as (x,y,z) tuples. For this there are special version of the advanced drawing functions:

 

d3d_primitive_begin(kind) Start a 3D primitive of the indicated kind: pr_pointlist, pr_linelist, pr_linestrip,pr_trianglelist,pr_trianglestrip or pr_trianglefan.

d3d_vertex(x,y,z) Add vertex (x,y,z) to the primitive, using the color and alpha value set before.

d3d_vertex_color(x,y,z,col,alpha) Add vertex (x,y,z) to the primitive, with its own color and alpha value. This allows you to create primitives with smoothly changing color and alpha values.

d3d_primitive_end() End the description of the primitive. This function actually draws it.

 

For example, to draw a tetrahedron (three sided pyramid) standing on the z=0 plane with its top at z = 200, you can use the following code:

 

 

{

d3d_primitive_begin(pr_trianglelist);

d3d_vertex(100,100,0);

d3d_vertex(100,200,0);

d3d_vertex(150,150,200);

d3d_vertex(100,200,0);

d3d_vertex(200,200,0);

d3d_vertex(150,150,200);

d3d_vertex(200,200,0);

d3d_vertex(100,100,0);

d3d_vertex(150,150,200);

d3d_vertex(100,100,0);

d3d_vertex(100,200,0);

d3d_vertex(200,200,0);

d3d_primitive_end();

}

 

Now if you would use this, most likely you would just see a triangle on the screen because the top of the tetrahedron will be behind it from the viewpoint. Also, using just one color, it would be difficult to see the different faces. Below we will see ways to change the viewpoint. Assigning colors can be done as before by added draw_set_color(col) function calls between the vertices.

 

You can also use textured poygons in 3D. It works exactly the same as described in the advanced drawing functions in the documentation. But this time you need 3D variants of the basic functions. One thing you must realize. In a texture the position (0,0) is the top-left corner. But often, when using projections (as indicated below), the bottom-left corner is (0,0). In such a case you might need to flip the texture vertically.

 

 

d3d_primitive_begin_texture(kind,texid) Start a 3D primitive of the indicated kind with the given texture.

d3d_vertex_texture(x,y,z,xtex,ytex) Add vertex (x,y,z) to the primitive with position (xtex,ytex) in the texture, blending with the color and alpha value set before.

d3d_vertex_texture_color(x,y,z,xtex,ytex,col,alpha) Add vertex (x,y,z) to the primitive with position (xtex,ytex) in the texture, blending with its own color and alpha value.

d3d_primitive_end() End the description of the primitive. This function actually draws it.

 

So, for example you can use the following code to draw a background image that disappears into the distance

 

 

{

var ttt;

ttt = background_get_texture(back);

d3d_primitive_begin_texture(pr_trianglefan,ttt);

d3d_vertex_texture(0,480,0,0,0);

d3d_vertex_texture(640,480,0,1,0);

d3d_vertex_texture(640,480,1000,1,1);

d3d_vertex_texture(0,480,1000,0,1);

d3d_primitive_end();

}

 

A triangle has a front and a back side. The front side is defined to be the side where the vertices are defined in counter-clockwise order. Normally both sides are drawn. But if you make a closed shape this is a waste because the backside of the triangle can never be seen. In this case you can switch on backface culling. This saves about half the amount of drawing time but it leaves you with the task of defining your polygons in the right way. The following function exists:

 

 

d3d_set_culling(cull) Indicates to start backface culling (true) or stop backface culling (false).

 

 

Drawing basic shapes

A number of functions exist for drawing basic shapes, like blocks and walls. Note that these shapes also work correctly with backface culling on.

 

 

d3d_draw_block(x1,y1,z1,x2,y2,z2,texid,hrepeat,vrepeat) Draws a block in the current color with the indicated opposite corners using the indicated texture. Use -1 to not use a texture. hrepeat indicates how often the texture must be repeated along the horizontal edge of each face. vrepeat does the same for the vertical edge.

d3d_draw_cylinder(x1,y1,z1,x2,y2,z2,texid,hrepeat,vrepeat,closed,steps) Draws a vertical cylinder in the current color in the indicated bounding box using the indicated texture. Use -1 to not use a texture. hrepeat indicates how often the texture must be repeated along the horizontal edge of each face. vrepeat does the same for the vertical edge. closed indicates whether to close the top and bottom of the cylinder. steps indicates how many rotational steps must be taken. A typical value is 24.

d3d_draw_cone(x1,y1,z1,x2,y2,z2,texid,hrepeat,vrepeat,closed,steps) Draws a vertical cone in the current color in the indicated bounding box using the indicated texture. Use -1 to not use a texture. hrepeat indicates how often the texture must be repeated along the horizontal edge of each face. vrepeat does the same for the vertical edge. closed indicates whether to close the top and bottom of the cylinder. steps indicates how many rotational steps must be taken. A typical value is 24.

d3d_draw_ellipsoid(x1,y1,z1,x2,y2,z2,texid,hrepeat,vrepeat,steps) Draws an ellipsoid in the current color in the indicated bounding box using the indicated texture. Use -1 to not use a texture. hrepeat indicates how often the texture must be repeated along the horizontal edge of each face. vrepeat does the same for the vertical edge. steps indicates how many rotational steps must be taken. A typical value is 24.

d3d_draw_wall(x1,y1,z1,x2,y2,z2,texid,hrepeat,vrepeat) Draws a vertical wall in the current color with the given corners using the indicated texture. Use -1 to not use a texture. hrepeat indicates how often the texture must be repeated along the horizontal edge of each face. vrepeat does the same for the vertical edge.

d3d_draw_floor(x1,y1,z1,x2,y2,z2,texid,hrepeat,vrepeat) Draws a (slanted) floor in the current color with the given corners using the indicated texture. Use -1 to not use a texture. hrepeat indicates how often the texture must be repeated along the horizontal edge of each face. vrepeat does the same for the vertical edge.

 

The following piece of code draws two blocks:

 

 

{

var ttt;

ttt = background_get_texture(back);

d3d_draw_block(20,20,20,80,40,200,ttt,1,1);

d3d_draw_block(200,300,-10,240,340,100,ttt,1,1);

}

 

 

 

Viewing the world

Default you look along the negative z-axis toward the middle of the room. Often in 3D games you want to change how you look at the world. For example, in a first person shooter you probably want to have the camera look from a position a bit above the xy-plane along the xy-plane. In graphics terms you are setting the correct projection. To change the way you look the following two functions exist.

 

d3d_set_projection(xfrom,yfrom,zfrom,xto,yto,zto,xup,yup,zup) Defines how to look in the world. You specify the point to look from, the point to look to and the up vector.

 

This function requires some explanation. To set the projection you first need the position you look from. This is indicated by the parameters (xfrom,yfrom,zfrom). Next you must specify the direction you look in. This is done by giving a second point to look towards. This is the point (xto,yto,zto). Finally, you can still rotate the camera around the line from the viewpoint to the looking point. To specify this we must give an up vector, that is, the direction that is upwards in the camera. This is given by the last three parameters (xup,yup,zup). Let me given an example. To look along the xy-plane as in a first person shooter you can use

 

 

{

d3d_set_projection(100,100,10,200,100,10,0,0,1);

}

 

So you look from point (100,100) and 10 above the plane in the direction of (200,100). The up vector points is the z-direction as required. To make this slightly more complicated, assume you have an instance in your room that specifies the position of the camera. It will have a current (x,y) position and a direction (and maybe even a speed). You can now specify this as your camera by using the following code:

 

{

with (obj_camera)

d3d_set_projection(x,y,10,

x+cos(direction*pi/180),y-sin(direction*pi/180),10,

0,0,1);

}

 

This might look a bit complicated. We look from the camera position (x,y), 10 above the ground. To determine a point in the correct direction we need to do a little arithmetic. This point is indicated by the next three parameters. Finally we use the up vector as above.

 

One important remark! When Game Maker starts drawing a room it will set the view point back to the default position. So the first thing you must do when drawing the scene is set is to the projection you want. This must be done in a drawing event!

 

There is also an extended version of the function above:

 

 

d3d_set_projection_ext(xfrom,yfrom,zfrom,xto,yto,zto,xup,yup,zup,angle,aspect,zn

ear,zfar) An extended version of this function in which you also specify the angle defining the field of view, the aspect ratio between horizontal and vertical size of the view, and the near and far clipping planes.

 

The additional parameters work as follows. If you specified the camera position, point to look at, and up vector, you can still change how wide the lens of the camera is. This is called the field of view. A reasonable value is 45 degrees and this is what is default taken. But you can change this if you like. Next you can specify the aspect ratio between the horizontal and vertical projection. Normally you want to use the same as the aspect ration of the room or view, e.g. 640/480. Finally you can indicate the clipping planes. Objects that are closer than znear to the camera are not drawn. Similar for objects further than zfar. It can be important to set these parameters to reasonable values because they also influence the precision of the z-comparisons. If you make the range too large the precision gets worse. Default we use 1 and 32000. znear must be larger than 0!

 

Sometimes you temporarily need a normal orthographic projection as is used when there is no 3D. Or you want to return to the default perspective projection. For this you can use the following functions:

 

 

d3d_set_projection_ortho(x,y,w,h,angle) Sets a normal orthographic projection of the indicated area in the room, rotated over the indicated angle.

d3d_set_projection_perspective(x,y,w,h,angle) Sets a normal perspective projection of the indicated area in the room, rotated over the indicated angle.

 

A standard use for this is to draw an overlay to e.g. show the score or other aspects. To do so we set an orthographic projection. We also must temporarily switch off hidden surface removal cause we want the information to be drawn regardless of the current depth value.

 

 

 

 

The following example shows how to create an overlay with the score.

 

 

 

{

draw_set_color(c_black);

d3d_set_projection_ortho(0,0,room_width,room_height,0);

d3d_set_hidden(false);

draw_text(10,10,'Score: ' + string(score));

d3d_set_hidden(true);

}

 

 

Transformations

Transformation allow you to change the place where things are drawn in the world. For example, the function to draw blocks can only draw axis-parallel blocks. By first setting a rotation transformation you can create rotated blocks. Also sprites are always drawn parallel to the xy-plane. By setting a transformation you can change this. There are two types of functions: functions that set the transformation and functions that add transformations.

 

d3d_transform_set_identity() Sets the transformation to the identity (no transformation).

d3d_transform_set_translation(xt,yt,zt) Sets the transformation to a translation over the indicated vector.

d3d_transform_set_scaling(xs,ys,zs) Sets the transformation to a scaling with the indicated amounts.

d3d_transform_set_rotation_x(angle) Sets the transformation to a rotation around the x-axis with the indicated amount.

d3d_transform_set_rotation_y(angle) Sets the transformation to a rotation around the y-axis with the indicated amount.

d3d_transform_set_rotation_z(angle) Sets the transformation to a rotation around the z-axis with the indicated amount.

d3d_transform_set_rotation_axis(xa,ya,za,angle) Sets the transformation to a rotation around the axis indicated by the vector with the indicated amount.

d3d_transform_add_translation(xt,yt,zt) Adds a translation over the indicated vector.

d3d_transform_add_scaling(xs,ys,zs) Adds a scaling with the indicated amounts.

d3d_transform_add_rotation_x(angle) Adds a rotation around the x-axis with the indicated amount.

d3d_transform_add_rotation_y(angle) Adds a rotation around the y-axis with the indicated amount.

d3d_transform_add_rotation_z(angle) Adds a rotation around the z-axis with the indicated amount.

d3d_transform_add_rotation_axis(xa,ya,za,angle) Adds a rotation around the axis indicated by the vector with the indicated amount.

 

Realize that rotation and scaling are with respect to the origin of the world, not with respect to the object that is to be drawn. If the object is not at the origin it will also move to a different place, which is not what we want. So to e.g. rotate an object over its own x-axis, we must first translate it to the origin, next rotate it, and finally translate it back to its position. This is what the functions to add transformations are for.

The following examples might explain this better. Assume we have a sprite spr that we want to draw at position (100,100,10).

 

 

We can use the following code to do this

 

 

{

d3d_transform_set_translation(100,100,10);

draw_sprite(spr,0,0,0);

d3d_transform_set_identity();

}

 

Note that because we use a translation we should now draw the sprite at position (0,0). (This assumes the current instance has a depth of 0! If you are not sure, first set the depth.) If we would use this in our first person shooter we would not see the sprite. The reason is that it is still parallel to the xy-plane. We want to rotate it over 90 degrees along the x-axis (or y-axis). So we need to add a rotation. Remember the order: we must first rotate the sprite and then translate it. So we can use the following code.

 

 

{

d3d_transform_set_identity();

d3d_transform_add_rotation_x(90);

d3d_transform_add_translation(100,100,10);

draw_sprite(spr,0,0,0);

d3d_transform_set_identity();

}

 

Sometimes you temporarily want to save the current transformation, for example to add an additional transformation and then restore the old one (this often happens when drawing hierarchical models). To this end you can push the current transformation on a stack and later pop it from the stack to make it the current transformation again. The following functions exist for this:

 

 

d3d_transform_stack_clear() Clears the stack of transformations.

d3d_transform_stack_empty() Returns whether the transformation stack is empty.

d3d_transform_stack_push() Pushes the current transformation on the stack. Returns whether there was room on the stack to push it there (if you forget popping transformation you at some moment will run out of room on the stack).

d3d_transform_stack_pop() Pops the top transformation from the stack and makes it the current one. Returns whether there was a transformation on the stack.

d3d_transform_stack_top() Makes the top transformation the current one, but does not remove it from the stack. Returns whether there was a transformation on the stack.

d3d_transform_stack_discard() Removes the top transformation from the stack but does not make it the current one. Returns whether there was a transformation on the stack.

 

Using transformation is a powerful mechanism. But be careful and always set the transformation back to the identity once you are done.

 

Fog

Fog can be used in 3D games to make objects in the distance look blurred or even disappear. This helps in creating atmosphere and it makes it possible to not draw objects that are far away. To enable or disable fog use the following function:

 

d3d_set_fog(enable,color,start,end) Enables or disables the use of fog. color indicates the fog color.

Start indicates the distance at which fog must start. end indicates the distance at which fog is maximal and nothing can be seen anymore.

 

To better understand what is happening, there are actually two types of fog, table based fog and vertex based fog. The first type calculates fog values on a pixel basis. The second type calculates the fog value for each vertex and then interpolates these. The first type is better but not always supported. Game Maker tries to use table based fog when supported and otherwise uses vertex based fog (unless no fog is supported). Note that certain graphics card indicate that they can handle table based fog but offer the user the possibility to switch this off in the advanced display settings. In this case the result might be a black screen!

 

 

Lighting

 

Scenes you draw with the functions above look rather flat because there is no light. The color if the faces is equal, independent of their orientation. To create more realistically looking scenes you must enable lighting and place lights at the correct places. Creating correctly lit scenes is not easy but the effect is very good.

To enable lighting you can use the following function;

 

 

d3d_set_lighting(enable) Enables or disables the use of lighting.

 

When using lighting, for each vertex of a polygon the color is determined. Next, the color of internal pixels is based on the color of these vertices. There are two ways this can be done: Either the whole polygon gets the same color, or the color is smoothly interpolated over the polygon. Default smooth shading is used. This can be changed using the following function:

 

 

d3d_set_shading(smooth) Set whether to use smooth shading or not.

 

To use lighting you obviously need to define lights. Two different lights exist: directional lights (like the sun), and positional lights. Light have a color. (We only support diffuse light, not specular reflection.) The following functions exist to define and use lights:

 

 

d3d_light_define_direction(ind,dx,dy,dz,col) Defines a directed light. ind is the index of the light (use a small positive number). (dx,dy,dz) is the direction of the light. col is the color of the light (often you want to use c_white. This function does not turn the light on.

d3d_light_define_point(ind,x,y,z,range,col) Defines a point light. ind is the index of the light use a small positive number). (x,y,z) is the position of the light. range indicates till how far the light shines. The intensity of the light will decrease over this range. col is the color of the light. This function does not turn the light on.

d3d_light_enable(ind,enable) Enables (true) or disables (false) light number ind.

 

The way an object reflects light depends on the angle between the light direction and the normal of the surface, that is, the vector pointing away from the surface. Hence, to create lighted objects you need not only provide the position of the vertices but also their normals.

 

 

For this four additional functions are avaliable to define the vertices of primitives:

 

 

d3d_vertex_normal(x,y,z,nx,ny,nz) Add vertex (x,y,z) to the primitive, with normal vector (nx,ny,nz).

d3d_vertex_normal_color(x,y,z,nx,ny,nz,col,alpha) Add vertex (x,y,z) to the primitive, with normal vector (nx,ny,nz), and with its own color and alpha value.

d3d_vertex_normal_texture(x,y,z,nx,ny,nz,xtex,ytex) Add vertex (x,y,z) to the primitive, with normal vector (nx,ny,nz), and with position (xtex,ytex) in the texture, blending with the color and alpha value set before.

d3d_vertex_normal_texture_color(x,y,z,nx,ny,nz,xtex,ytex,col,alpha) Add vertex (x,y,z) to the primitive, with normal vector (nx,ny,nz), and with position (xtex,ytex) in the texture, blending with its own color and alpha value.

 

Note that for the basic shapes that you can draw the normals are automatically set correctly.

 

 

Creating models

 

When you need to draw large models it is rather expensive to call all the different drawing functions again and again in every step. To avoid this you can create models. A model consists of a number of drawing primitives and shapes. Once a model is created you can draw it at different places with just one function call. Models can also be loaded from a file or saved to a file.

Before giving the different functions available there is one important point: the handling of textures. As described earlier, texture are taken from sprites and backgrounds. The indices of the textures can be different at different moments. As a result models do not contain any texture information. Only when you draw a model you provide the texture. So you can only use one texture in a model. If you need more textures you must either combine them in one (and carefully deal with the texture coordinates) or you must use multiple models. The advantage of this is that you can draw the same model easily with different textures.

 

For creating, loading, saving, and drawing models, the following functions exist:

 

 

d3d_model_create() Creates a new model and returns its index. This index is used in all other functions dealing with models.

d3d_model_destroy(ind) Destroys the model with the given index, freeing its memory.

d3d_model_clear(ind) Clears the model with the given index, removing all its primitives.

d3d_model_save(ind,fname) Saves the model to the indicated file name.

d3d_model_load(ind,fname) Loads the model from the indicated file name.

d3d_model_draw(ind,x,y,z,texid) Draws the model at position (x,y,z). texid is the texture that must be used. Use -1 if you do not want to use a texture. If you want to rotate or scale the model you can use the transformation routines described before.

 

 

 

 

 

 

 

 

For each primitive function there is an equivalent to add it to a model.

The functions have the same arguments as before except that each has a first argument the index of the model, and no texture information is provided.

 

 

d3d_model_primitive_begin(ind,kind) Adds a 3D primitive to the model of the indicated kind: pr_pointlist, pr_linelist, pr_linestrip,pr_trianglelist,pr_trianglestrip or pr_trianglefan.

d3d_model_vertex(ind,x,y,z) Add vertex (x,y,z) to the model.

d3d_model_vertex_color(ind,x,y,z,col,alpha) Add vertex (x,y,z) to the model, with its own color and alpha value.

d3d_model_vertex_texture(ind,x,y,z,xtex,ytex) Add vertex (x,y,z) to the model with position (xtex,ytex) in the texture.

d3d_model_vertex_texture_color(ind,x,y,z,xtex,ytex,col,alpha) Add vertex (x,y,z) to the model with texture and color values.

d3d_model_vertex_normal(ind,x,y,z,nx,ny,nz) Add vertex (x,y,z) to the model, with normal vector (nx,ny,nz).

d3d_model_vertex_normal_color(ind,x,y,z,nx,ny,nz,col,alpha) Add vertex (x,y,z) to the model, with normal vector (nx,ny,nz), and with its own color and alpha value.

d3d_model_vertex_normal_texture(ind,x,y,z,nx,ny,nz,xtex,ytex) Add vertex (x,y,z) to the model, with normal vector (nx,ny,nz), with texture position.

d3d_model_vertex_normal_texture_color(ind,x,y,z,nx,ny,nz,xtex,ytex,col,alpha) Add vertex (x,y,z) to the model, with normal vector (nx,ny,nz), with texture and color values.

d3d_model_primitive_end(ind) End the description of the primitive in the model.

 

Besides primitives you can also add basic shapes to the models. Again the functions look almost the same but with a model index and without texture information:

 

 

d3d_model_block(ind,x1,y1,z1,x2,y2,z2,hrepeat,vrepeat) Adds a block shape to the model.

d3d_model_cylinder(ind,x1,y1,z1,x2,y2,z2,hrepeat,vrepeat,closed,steps) Adds a cylinder shape to the model.

d3d_model_cone(ind,x1,y1,z1,x2,y2,z2,hrepeat,vrepeat,closed,steps) Adds a cone shape to the model.

d3d_model_ellipsoid(ind,x1,y1,z1,x2,y2,z2,hrepeat,vrepeat,steps) Adds a ellipsoid shape to the model.

d3d_model_wall(ind,x1,y1,z1,x2,y2,z2,hrepeat,vrepeat) Adds a wall shape to the model.

d3d_model_floor(ind,x1,y1,z1,x2,y2,z2,hrepeat,vrepeat) Adds a floor shape to the model.

 

Using models can considerable speed up the graphics in your 3D games and you should use them whenever you can.

 

 

Final words

 

The 3D functions in Game Maker can be used to make some nice 3D games. However, they are limited in functionality and still leave quite a lot of work to you.

Don't expect that you can make your own Quake with it. Game Maker is and remains primarily a package for making 2-dimensional games.

 

 

:thumbsup:

[Yoda]

Hmmm po co to skopiowałeś - przecież to samo jest w helpie :D

[Tomek_K]

no ale GMcliker chciał żeby mu wyjaśnić krok po kroku to mu dałem

[pager]

hehe ale długi pościor ;P

[Shylios]

Czyżby najdłuższy post w histori gmc? :o

[Bartek (Kamrat)]

Czyżby najdłuższy post w histori gmc? :o

niee, Ranmus czasem lubi napisać jakieś wypracowanie :P poza tym, jakieś 90% posta Tomek_Ka to wycinek helpa, więc sie nie liczy :D

[Marmot]

Zresztą, jemu chodziło o to jak używać programu Marzipan, bo ma model 3D zrobiony w Blenderze i chciałby go dać do Game Makera, a nie jak używać trybu 3D...

[Tsukuru]

Ja akurat nie używam grafiki 3D , bo oprócz Fify i Counter Strika nudzą mnei już te gry 3D , wymyslili by 4D i by bylo gites...

[Yoda]

wymyslili by 4D

Tak, tak a potem cię mama do szkoły obudziła... wiesz w ogóle jaki jest 4 wymiar? x_X

[Driger]

wiesz w ogóle jaki jest 4 wymiar? x_X

 

Matrix ? :P

 

 

Grafike , robisz w blenderze , zapisujesz w np .obj , potem importujesz do marzipana , a potem do gm'a

 

A jak chcesz wczytac model do Gm to poszukaj na forum , bo bylo to , i byl fajny przyklad kogos , "egypt" czy cos takiego