N64 3D modeling software options

Hi Folks,

I'm just starting to mess around with basic N64 programming.
I'm wondering if anyone here has any of the original 3D modeling software that was used with N64 games?
To design and output 3D models into the format needed for N64 game C programming?

The N64 dev manuals make reference to "NinGen" and also "3D Studio" and "Alias".
Apparently these programs could output to the format used with the N64?
Matrices coordinate data?

Just wondering what would be the best software to use? apparently the software could design and manipulate the 3D matrix data. I've used 3D studio Max before but was always just using .max anf .3ds format files. So I'm not sure what format to output the 3D models to... and how I would incorporate that into my N64 C code?

In my N64 C code so far...I've messed around with manipulating basic triangle matrices and vertex data,
basic rotations using the Game controller data to move things around on the screen...but that's about it so far. I wanted to start getting into 3D models a bit....just to see whats possible.

Anyone have a copy of the NinGen software?
or know what format I have to output to if I use another application?

Any help would be greatly appreciated.

Cheers!
-Gerry

 

Wow, you are going back into ancient history here

NinGen was a special modified version of a package called "MultiGen" that was originally designed for visual simulation applications (things like flight simulators), the NinGen version lost some of the fancy features, but came with a built-in exporter for N64 models. Alias (aka 'PowerAnimator') was another modelling/animation package that was the flagship product of a company called Alias Research based in Toronto, who SGI contracted to produce a special version (also with direct model output) for Project Reality / N64. At one point, the exporters for N64 were part of the standard package, although unsupported - but even if you could find an ancient copy of PowerAnimator you would need to find an old SGI running IRIX (or IBM's AIX?) to run it. Later, SGI bought Alias, merged them with Wavefront (another 3D package company who had some nice animation tools) and imaginatively named the result "Alias | Wavefront" - this is basically the package that later turned into Maya.

Since IIRC the full PA bundle was something like $30k/seat with all the addons and the SGI machines you needed to run it were also incredibly expensive they also decided to support a lower cost option, which was 3D Studio (this is the original DOS based 3DS, not the later 3DS MAX). I have a vague memory that the exporters for 3DS were not in the standard package and you had to get them from Nintendo and install them as plugins.

There were a few other packages that could generate stuff for the N64 - the only other one I can remember right now was produced by a company called Nichimen Graphics, and was likely the only commercial grade animation package ever written completely in Lisp. It also had an active preview module so you could display your models in real-time on an N64 attached to the workstation - this option was called "Instant Gratification" - and is really the main reason I remember the product

I think your best bet is to get an old DOS machine running something like 3DS R4 and try and find the exporters from somewhere - they might have been in the N64 SDK, but I'm not 100% on that.

 

Hello brother!!! Yeah. I also have a dream to create a game for N64 someday, most especifically, port Half Life One to N64 (off course a simplified version). However I lack the programming knowledge to do this, because, you know you need to create first the engine to develop your game for N64. My only hope would be if that guy SilliconClassics would distribute for free the source code of Turok N64, then I would use this to create a kind of Total Conversion MOD of Turok N64 by turning it on Half Life 64

Like TriMesh said, it will be hard to find an old software to export your models to N64 native format.

My humble opinion, I think the best would be create a plugin, a maxscript to export from 3dsmax to native N64 format. I think this is not impossible, you should try to contact SubDrag, the developer of Goldeneye Setup Editor (goldeneyevault.com) because this guy and his supporter, they reverse engineered the Goldeneye 007 and Perfect Dark N64 Engines, so is even possible to import custom models in OBJ format inside Goldeneye 007 (rom hacking). Recently they discovered the Animation System Format of GE and PD, so that they allowed you to import FBX animations inside the game.

So i think they already have the knowledge of the N64 Model Structure Format, so it is just they create a plugin for some current gen software (3dsmax, Maya, Blender, Softimage,...) to export the model and animation to N64 Native Format.

Cheers.

 

Use any modern 3D modelling package that has a Wavefront OBJ export module and then use Obj2N64.

See this thread for more details :-

http://assemblergames.com/l/threads/sn-systems-n64-game-development-kit.59341/

 

This is amazing info all around guys! Thanks a mint!

I know my version of 3D Studio MAX software has the .OBJ export option.
So I'll give that a go and will post back after I play around with this a bit tonight.

Cheers!
-Gerry

 

Thanks for the links, cmonkey, and thanks for the thorough and informative history, TriMesh.

 

Ok,
So I got it to convert an simple .OBJ 3D model of a simple box that I rendered in 3D Studio MAX and then exported it out.
Used the .exe to compile it and got the Vertices data to mix into my C code.

Code:

Vtx boxVertices[] =
{
    { 0, 0, 0, 0, 32767, 2048, 127, 0, 0, 0xff },
    { 0, 0, 1, 0, 32767, -32768, 127, 0, 0, 0xff },
    { 0, -1, 1, 0, 0, -32768, 127, 0, 0, 0xff },
    { 0, -1, 0, 0, 0, 2048, 127, 0, 0, 0xff },
    { -4, 0, 0, 0, 0, 2048, -128, 0, 0, 0xff },
    { -4, -1, 0, 0, 32767, 2048, -128, 0, 0, 0xff },
    { -4, -1, 1, 0, 32767, -32768, -128, 0, 0, 0xff },
    { -4, 0, 1, 0, 0, -32768, -128, 0, 0, 0xff },
    { 0, 0, 0, 0, 0, 2048, 0, 0, -128, 0xff },
    { 0, -1, 0, 0, 32767, 2048, 0, 0, -128, 0xff },
    { -4, -1, 0, 0, 32767, -32768, 0, 0, -128, 0xff },
    { -4, 0, 0, 0, 0, -32768, 0, 0, -128, 0xff },
    { 0, -1, 0, 0, 0, 2048, 0, -128, 0, 0xff },
    { 0, -1, 1, 0, 32767, 2048, 0, -128, 0, 0xff },
    { -4, -1, 1, 0, 32767, -32768, 0, -128, 0, 0xff },
    { -4, -1, 0, 0, 0, -32768, 0, -128, 0, 0xff },
    { 0, -1, 1, 0, 0, 2048, 0, 0, 127, 0xff },
    { 0, 0, 1, 0, 32767, 2048, 0, 0, 127, 0xff },
    { -4, 0, 1, 0, 32767, -32768, 0, 0, 127, 0xff },
    { -4, -1, 1, 0, 0, -32768, 0, 0, 127, 0xff },
    { 0, 0, 1, 0, 0, 2048, 0, 127, 0, 0xff },
    { 0, 0, 0, 0, 32767, 2048, 0, 127, 0, 0xff },
    { -4, 0, 0, 0, 32767, -32768, 0, 127, 0, 0xff },
    { -4, 0, 1, 0, 0, -32768, 0, 127, 0, 0xff },
};

Gfx boxDisplayList[] =
{
    gsSPVertex(&boxVertices[0], 16, 0),
    gsDPPipeSync(),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(0, 2, 3, 0),
    gsSP1Triangle(4, 5, 6, 0),
    gsSP1Triangle(4, 6, 7, 0),
    gsSP1Triangle(8, 9, 10, 0),
    gsSP1Triangle(8, 10, 11, 0),
    gsSP1Triangle(12, 13, 14, 0),
    gsSP1Triangle(12, 14, 15, 0),
    gsDPPipeSync(),
    gsSPVertex(&boxVertices[16], 8, 0),
    gsDPPipeSync(),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(0, 2, 3, 0),
    gsSP1Triangle(4, 5, 6, 0),
    gsSP1Triangle(4, 6, 7, 0),
    gsDPPipeSync(),
};

Nice!! )
Cheers!
-Gerry

 

I recently touched base with a fellow N64 programmer... AKA "DEADCAST" on another forum. He has been doing some in-depth research to learn N64 programming over the years. He just recently wrote some code to load a 3D .sos model on the N64 and have it rotate in 3D.

Check his video example below... pretty cool stuff.


Code for his 3D Model Viewer:
https://github.com/deadcast/n64-model-viewer

Pretty Sweet!!
-Gerry

 

Not quite exactly how it went, but close enough
Jolly

 

Hi Folks,
I'm back again with yet another update...

So I decided to export a Nintendo 64 "N" logo with 3D Studio Max,
and once again used the OBJ2N64.exe to compile the model Vertices to the C code format.
As you can see the model is a bit more complex than the other Box.... . In turn the code is tad bit longer.

Code:

Vtx N64LogoVertices[] =
{
    { -29, 0, 29, 0, 0, 2048, -115, -38, 38, 0xff },
    { -29, 57, 29, 0, 0, 2048, -51, 52, 104, 0xff },
    { -29, 57, 12, 0, 0, 2048, -61, 62, -93, 0xff },
    { -29, 27, 12, 0, 0, 2048, -126, 20, -7, 0xff },
    { -29, 0, 12, 0, 0, 2048, -75, -99, -28, 0xff },
    { 29, 0, 12, 0, 0, 2048, 60, -62, -93, 0xff },
    { 29, 57, 12, 0, 0, 2048, 73, 82, -64, 0xff },
    { 29, 57, 29, 0, 0, 2048, 85, 42, 84, 0xff },
    { 29, 0, 29, 0, 0, 2048, 51, -52, 104, 0xff },
    { 13, 26, 12, 0, 0, 2048, -30, 15, -123, 0xff },
    { 13, 0, 12, 0, 0, 2048, -36, -78, -94, 0xff },
    { -13, 30, 12, 0, 0, 2048, -15, -39, -120, 0xff },
    { -13, 57, 12, 0, 0, 2048, 57, 85, -75, 0xff },
    { -13, 26, 12, 0, 0, 2048, 123, 31, -11, 0xff },
    { 13, 0, 29, 0, 0, 2048, -46, -102, 60, 0xff },
    { 13, 57, 29, 0, 0, 2048, -102, 68, 33, 0xff },
    { 13, 57, 12, 0, 0, 2048, -94, 77, -36, 0xff },
    { 29, 29, 12, 0, 0, 2048, 45, -33, -114, 0xff },
    { 13, 30, 12, 0, 0, 2048, -120, -39, 15, 0xff },
    { 29, 26, -13, 0, 0, 2048, 126, 20, 7, 0xff },
    { 29, 0, -30, 0, 0, 2048, 85, -85, -42, 0xff },
    { 29, 57, -30, 0, 0, 2048, 68, 34, -102, 0xff },
    { 29, 57, -13, 0, 0, 2048, 33, 68, 102, 0xff },
    { 13, 26, -13, 0, 0, 2048, -121, 38, 14, 0xff },
    { 13, 0, -30, 0, 0, 2048, -102, -34, -68, 0xff },
    { 13, 0, -13, 0, 0, 2048, -75, -99, 28, 0xff },
    { 13, 27, 29, 0, 0, 2048, 12, 32, 123, 0xff },
    { 29, 0, -13, 0, 0, 2048, 93, -73, 47, 0xff },
    { 13, 57, -30, 0, 0, 2048, -47, 101, -61, 0xff },
    { 13, 57, -13, 0, 0, 2048, -36, 77, 94, 0xff },
    { 13, 30, -13, 0, 0, 2048, -37, -19, 120, 0xff },
    { 13, 30, -30, 0, 0, 2048, 15, -39, -120, 0xff },
    { -29, 57, -30, 0, 0, 2048, -85, 42, -84, 0xff },
    { -29, 0, -30, 0, 0, 2048, -52, -52, -104, 0xff },
    { -29, 0, -13, 0, 0, 2048, -39, -56, 107, 0xff },
    { -29, 57, -13, 0, 0, 2048, -41, 98, 70, 0xff },
    { -13, 0, -30, 0, 0, 2048, 28, -99, -75, 0xff },
    { -13, 26, -30, 0, 0, 2048, 30, 15, -123, 0xff },
    { -13, 26, -13, 0, 0, 2048, -16, 38, 120, 0xff },
    { -13, 0, -13, 0, 0, 2048, 57, -86, 75, 0xff },
    { -13, 57, -30, 0, 0, 2048, 85, 85, -41, 0xff },
    { -13, 30, -13, 0, 0, 2048, 123, -15, 30, 0xff },
    { -29, 29, -13, 0, 0, 2048, -91, -87, 20, 0xff },
    { -13, 57, -13, 0, 0, 2048, 94, 77, 36, 0xff },
    { -13, 0, 29, 0, 0, 2048, 43, -73, 95, 0xff },
    { -13, 0, 12, 0, 0, 2048, 75, -86, -56, 0xff },
    { -13, 57, 29, 0, 0, 2048, -1, 91, 89, 0xff },
    { -13, 29, 29, 0, 0, 2048, 21, -31, 122, 0xff },
};

Gfx N64LogoDisplayList[] =
{
    gsSPVertex(&N64LogoVertices[0], 16, 0),
    gsDPPipeSync(),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(0, 2, 3, 0),
    gsSP1Triangle(0, 3, 4, 0),
    gsSP1Triangle(5, 6, 7, 0),
    gsSP1Triangle(5, 7, 8, 0),
    gsSP1Triangle(9, 5, 10, 0),
    gsSP1Triangle(9, 10, 11, 0),
    gsSP1Triangle(11, 2, 12, 0),
    gsSP1Triangle(11, 12, 9, 0),
    gsSP1Triangle(2, 11, 13, 0),
    gsSP1Triangle(2, 13, 3, 0),
    gsSP1Triangle(14, 10, 5, 0),
    gsSP1Triangle(14, 5, 8, 0),
    gsSP1Triangle(15, 7, 6, 0),
    gsDPPipeSync(),
    gsSPVertex(&N64LogoVertices[5], 2, 0),
    gsSPVertex(&N64LogoVertices[9], 1, 2),
    gsSPVertex(&N64LogoVertices[15], 12, 3),
    gsDPPipeSync(),
    gsSP1Triangle(3, 1, 4, 0),
    gsSP1Triangle(5, 0, 2, 0),
    gsSP1Triangle(5, 2, 6, 0),
    gsSP1Triangle(7, 8, 9, 0),
    gsSP1Triangle(7, 9, 10, 0),
    gsSP1Triangle(11, 12, 13, 0),
    gsSP1Triangle(11, 13, 6, 0),
    gsSP1Triangle(6, 3, 4, 0),
    gsSP1Triangle(6, 4, 11, 0),
    gsSP1Triangle(3, 6, 2, 0),
    gsSP1Triangle(3, 2, 14, 0),
    gsDPPipeSync(),
    gsSPVertex(&N64LogoVertices[5], 4, 0),
    gsSPVertex(&N64LogoVertices[14], 2, 4),
    gsSPVertex(&N64LogoVertices[17], 1, 6),
    gsSPVertex(&N64LogoVertices[19], 4, 7),
    gsSPVertex(&N64LogoVertices[24], 5, 11),
    gsDPPipeSync(),
    gsSP1Triangle(13, 4, 3, 0),
    gsSP1Triangle(13, 3, 2, 0),
    gsSP1Triangle(5, 13, 2, 0),
    gsSP1Triangle(14, 8, 7, 0),
    gsSP1Triangle(14, 7, 1, 0),
    gsSP1Triangle(14, 1, 6, 0),
    gsSP1Triangle(1, 0, 6, 0),
    gsSP1Triangle(8, 14, 12, 0),
    gsSP1Triangle(8, 12, 11, 0),
    gsSP1Triangle(10, 9, 15, 0),
    gsDPPipeSync(),
    gsSPVertex(&N64LogoVertices[20], 5, 0),
    gsSPVertex(&N64LogoVertices[28], 11, 5),
    gsDPPipeSync(),
    gsSP1Triangle(2, 5, 6, 0),
    gsSP1Triangle(4, 3, 7, 0),
    gsSP1Triangle(4, 7, 8, 0),
    gsSP1Triangle(4, 8, 1, 0),
    gsSP1Triangle(4, 1, 0, 0),
    gsSP1Triangle(9, 10, 11, 0),
    gsSP1Triangle(9, 11, 12, 0),
    gsSP1Triangle(13, 10, 14, 0),
    gsSP1Triangle(13, 14, 8, 0),
    gsSP1Triangle(5, 1, 8, 0),
    gsSP1Triangle(5, 8, 14, 0),
    gsSP1Triangle(7, 2, 6, 0),
    gsSP1Triangle(7, 6, 15, 0),
    gsDPPipeSync(),
    gsSPVertex(&N64LogoVertices[6], 1, 0),
    gsSPVertex(&N64LogoVertices[16], 4, 1),
    gsSPVertex(&N64LogoVertices[22], 2, 5),
    gsSPVertex(&N64LogoVertices[25], 1, 7),
    gsSPVertex(&N64LogoVertices[27], 1, 8),
    gsSPVertex(&N64LogoVertices[30], 1, 9),
    gsSPVertex(&N64LogoVertices[32], 1, 10),
    gsSPVertex(&N64LogoVertices[34], 1, 11),
    gsSPVertex(&N64LogoVertices[37], 4, 12),
    gsDPPipeSync(),
    gsSP1Triangle(13, 11, 14, 0),
    gsSP1Triangle(13, 14, 9, 0),
    gsSP1Triangle(5, 9, 6, 0),
    gsSP1Triangle(5, 6, 4, 0),
    gsSP1Triangle(3, 7, 8, 0),
    gsSP1Triangle(3, 8, 2, 0),
    gsSP1Triangle(4, 6, 0, 0),
    gsSP1Triangle(6, 1, 0, 0),
    gsSP1Triangle(10, 15, 12, 0),
    gsDPPipeSync(),
    gsSPVertex(&N64LogoVertices[0], 1, 0),
    gsSPVertex(&N64LogoVertices[4], 1, 1),
    gsSPVertex(&N64LogoVertices[32], 14, 2),
    gsDPPipeSync(),
    gsSP1Triangle(2, 7, 3, 0),
    gsSP1Triangle(6, 9, 4, 0),
    gsSP1Triangle(6, 4, 3, 0),
    gsSP1Triangle(4, 8, 11, 0),
    gsSP1Triangle(4, 11, 12, 0),
    gsSP1Triangle(4, 12, 5, 0),
    gsSP1Triangle(10, 2, 5, 0),
    gsSP1Triangle(10, 5, 13, 0),
    gsSP1Triangle(14, 0, 1, 0),
    gsSP1Triangle(14, 1, 15, 0),
    gsDPPipeSync(),
    gsSPVertex(&N64LogoVertices[1], 2, 0),
    gsSPVertex(&N64LogoVertices[9], 4, 2),
    gsSPVertex(&N64LogoVertices[14], 1, 6),
    gsSPVertex(&N64LogoVertices[26], 1, 7),
    gsSPVertex(&N64LogoVertices[28], 2, 8),
    gsSPVertex(&N64LogoVertices[37], 2, 10),
    gsSPVertex(&N64LogoVertices[46], 2, 12),
    gsDPPipeSync(),
    gsSP1Triangle(5, 12, 7, 0),
    gsSP1Triangle(5, 7, 2, 0),
    gsSP1Triangle(4, 3, 6, 0),
    gsSP1Triangle(4, 6, 13, 0),
    gsSP1Triangle(12, 5, 1, 0),
    gsSP1Triangle(12, 1, 0, 0),
    gsSP1Triangle(13, 6, 7, 0),
    gsSP1Triangle(13, 7, 12, 0),
    gsSP1Triangle(11, 9, 8, 0),
    gsSP1Triangle(11, 8, 10, 0),
    gsDPPipeSync(),
    gsSPVertex(&N64LogoVertices[0], 2, 0),
    gsSPVertex(&N64LogoVertices[3], 2, 2),
    gsSPVertex(&N64LogoVertices[13], 1, 4),
    gsSPVertex(&N64LogoVertices[30], 2, 5),
    gsSPVertex(&N64LogoVertices[35], 2, 7),
    gsSPVertex(&N64LogoVertices[39], 1, 9),
    gsSPVertex(&N64LogoVertices[41], 6, 10),
    gsDPPipeSync(),
    gsSP1Triangle(9, 8, 6, 0),
    gsSP1Triangle(9, 6, 5, 0),
    gsSP1Triangle(7, 2, 4, 0),
    gsSP1Triangle(7, 4, 12, 0),
    gsSP1Triangle(1, 0, 13, 0),
    gsSP1Triangle(1, 13, 15, 0),
    gsSP1Triangle(11, 3, 2, 0),
    gsSP1Triangle(11, 2, 7, 0),
    gsSP1Triangle(4, 13, 14, 0),
    gsSP1Triangle(4, 14, 10, 0),
    gsDPPipeSync(),
    gsSPVertex(&N64LogoVertices[4], 1, 0),
    gsSPVertex(&N64LogoVertices[11], 1, 1),
    gsSPVertex(&N64LogoVertices[13], 1, 2),
    gsSPVertex(&N64LogoVertices[37], 2, 3),
    gsSPVertex(&N64LogoVertices[40], 8, 5),
    gsDPPipeSync(),
    gsSP1Triangle(6, 5, 8, 0),
    gsSP1Triangle(6, 8, 2, 0),
    gsSP1Triangle(6, 4, 3, 0),
    gsSP1Triangle(6, 3, 5, 0),
    gsSP1Triangle(12, 11, 9, 0),
    gsSP1Triangle(12, 9, 2, 0),
    gsSP1Triangle(12, 2, 1, 0),
    gsSP1Triangle(7, 6, 10, 0),
    gsSP1Triangle(7, 10, 0, 0),
    gsDPPipeSync(),
};

I tried to get it rendering in DeadCast's 3D Viewer code...but it was freezing on me. (

I sent Deadcast the vertices Matrix data and he managed to adjust some of the model rotation properties in the DisplayList setup process.... and Voila!!
Check it out!!


Pretty cool developments.

Cheers!
-Gerry

 

WOW, it`s amazing!!!

Oh my childhood times!!!

Whenever I played my N64, it was a dream for me draw something on 3D (on that time I did not even have a computer ) and get it running inside my N64!!!

Now you guys did it!!! Congratulations

 

Cool stuff the idea of making games came during my childhood N64 as well looking at in development games. Unfortunately never learned much beyond but not now with Unity for 3DS/Wii U can get a bit of the taste of a nintendo developer everything so easy and pc like it's nowhere near as satisfying as what you did

 

Hello Gerry, you should probally try to contact this guy, the creator of this video (marshallgs):



In my opinion, he is the most talented N64 homebrew developer I ever got to know (hear about). He is the guy who developed the 64drive (http://64drive.retroactive.be/) which is an alternative to Everdrive 64.

You could get with him some ideas, tutorials, or even the source code of the samples you see in the video.

Try it!