R-Pi Massively Multiplayer Online Role-Playing Games (MMORPG)

[Jim Manley]

Great progress, Pete!  I've also now got Panda3D running on one of my laptops and I have been torturing the poor demo panda by making it wander randomly about the bamboo forest clearing, along with varying camera angles and perspectives beyond the simple spin in the original example.  I've also downloaded the Panda3D source to the Pi in the UK to which I have remote access, but, I don't currently have space to start trying to build it there until the board owner expands the Debian 2 GB release to fill the entire 8 GB SD card in the Pi (expected to occur imminently).

I won't really be able to run Panda3D to produce dynamic 3-D graphics on the remotely-accessed Pi anyway until I receive my Pi board, since I can't see anything sent to the framebuffer over the VNC link, which can only be attached to an X window instance.  I'm working on saving snapshots from the framebuffer generated from the simple Python ES demos just to help establish proof-of-life for my code stubs.

PeteX, n3tw0rk5, SN, Tass, quitequick, and ModMyPi have let me know they have experience relevant to the project and have expressed interest via PMs in helping technically and in other ways.  There are others who are ready to provide support when we get the really hard stuff working, but, if anyone else is interested in participating technically whom I have missed, please let me know here or via PM.  Now that boards are starting to show up (n3tw0rk5 and Tass both have theirs and the rest of us should within a few weeks of receiving ours), I'm prepping a server where we will be able to collaborate via private chat, share source, run service executables, post WebGL visualizations of what things could look like in ES, etc.

To paraphrase the legal requirement for a certain violent sexual act, progress, no matter how slight, is sufficient to complete the crime

[PeteX]

First of all, I fixed the problems with the Blender exporter, so I've been able to get the human figure and the walk cycle into Panda.  To be fair, the problems were largely self-inflicted because I insisted on using Blender 2.63 even though the exporter was still targeting 2.62.

These changes have now been pushed to the repository, so if you update your installation you should see them.

Hi Jim,

Well done getting Panda3D running, plus the demo panda.  I first saw that demo ages ago, and I was really impressed—just a few lines of code to produce a real 3D scene.  I had all sorts of ideas for things I was going to do with it, but then it all went nowhere because I couldn't import my own models.  Now at last there is hope!

It's great that you're planning to build Panda on the Pi.  That's a significant piece of work that is totally separate from what I'm doing.  Because of this, we should be able to work concurrently without falling over each other's changes.  I think I'll probably produce some more artwork next.  It will have to be done sooner or later, and I think the project becomes much more credible if it looks good.  A lot of open source game projects fail because of bad artwork, so we need to prove that this one is different.

I hadn't realised so many people were interested in helping, but it's fantastic news.  If you're interested in helping, please let us know what you want to work on, or what you need in order to get up to speed with the code.  Of course this will get easier as the project gets a bit more mature.  At the moment a lot of the design is up in the air, so we'll need to discuss the way various things ought to work, so we're pulling in the same direction.  (In particular, most of the code that loads scenes needs to be replaced.  At the moment the server doesn't have control over the scene that gets loaded, which obviously isn't satisfactory.)


I'm prepping a server where we will be able to collaborate via private chat, share source, run service executables, post WebGL visualizations of what things could look like in ES, etc.


A little while ago I registered friendlyfruit.org.  (Registering domain names is cheap, so I think it makes sense to do it at the start of a project.  It would be annoying to get some way down the road and then have to rename the project because the domain name has been taken.)  I was going to point this at my own web hosting, but it might make more sense to point it at the server you're setting up—what do you think?

[PeteX]

I've checked in four stock trees, for building landscapes.

https://www.chown.org.uk/files/trees.jpg

[PeteX]

I've just checked in some more artwork: terrain, a skybox, and the beginnings of a starting zone. In the demo game, it is likely that new characters will appear in this zone for the quests that will be included in order to demonstrate the system. Here is a screenshot (rendered by Blender not Panda):

https://www.chown.org.uk/files/scene.jpg

You can of course download the image files and blends from github, but they haven't been imported into the game yet, so you can't actually walk around this new area. Incidentally, behind the area you can see in the screenshot, there is about a kilometre of empty space, all ready for terraforming by the people who download and customise the server.

[Jim Manley]

Thanks for the updates to your Panda3D world Pete. I haven't had a chance to try them out for reasons that will become clear below, as you've probably already guessed from my recent posts in another thread.

So, I finally received a Pi from RS courtesy of one of our Pi-finity! team members who had already received one from Farnell (the one I have been logged into via ssh and VNC the last few weeks), and he was kind enough to offer me the opportunity to complete the order for the second board in his stead. It arrived Friday afternoon and I replicated my experience of the first few days and nights after acquiring my first Apple ][ in 1977, and wound up not getting much sleep the last few days. As documented in my thread "Houston, Tranquility Base: The Pi-gle Has Landed", once I had the board booted up and had run through a brief proof-of-life check on the usual suspects throughout the file system, I immediately set about building and running the OpenGL ES 2.0 demos in /opt/vc/src/hello_pi/... They run flawlessly, and the hello_triangle demo code is pretty straightforward to someone familiar with OGL(ES) in showing how to set up and render OGLES to the framebuffer in full-screen mode, which features a cube rotating about all three axes with three images texture-mapped to the cube's six faces.

I also downloaded the OGLES examples discussed in http://benosteen.wordpress.com/2012/04/ ... -x-windows and, while they do build with the Makefile provided once the .conf file specified has been created and libconf is run, not all of the demos displayed something. That's OK, the things that did run showed that most of the OGLES capability is readily accessible. One of the problems with OGL, in general, is that there are so many ways to skin the proverbial cat (as in applying a texture map to a cat model, not anything PETA would disapprove of, naturally ) that figuring out how to do something in particular can take quite a while of digging through the documentation, on-line examples, etc.

Eventually, I'm hoping to have a way of experimenting with code via WebGL and then readily porting the code to run on the Pi with as little modification pain as possible, since WebGL essentially encapsulates OGLES 2.0, with a few restrictions that are easy to accommodate with a bit of advance planning. The easy part is that ports would be from a more restrictive environment to a less restrictive one, and the differences aren't really that difficult to accommodate. The required effort might be as large as development of the initial version of Pi-finity! though, in the big scheme of things.

For those not well-versed in the Graphics Library Shading Language (GLSL), a C-syntax compiled language that is used to create shaders in OGL and OGLES 2.0, a link on another of benosteen's Wordpress site references the interactive GLSL sandbox at http://glsl.heroku.com where there are some amazing examples of what can be done just with GLSL. It appears to be implemented with a WebGL interface overlying a GLSL compiler running on the web server, and you can apparently upload edited versions of the examples provided and immediately see the results of the changes (or whether it will even compile, which is just as useful to know). There is a gallery of more examples than I could navigate through, from very simple plain spheres with a shadow to things that could have been part of the psychedelia sequence as astronaut Dave Bowman passed through the monolith gateway in "2001: A Space Odyssey". It's the best way to comprehend both the basic principles and advanced features of GLSL I've seen yet.

I'm trying to hack together some OGLES demos to show off at the Maker Faire in San Mateo this coming Saturday and Sunday, so, I won't be looking at how we might port at least parts of a game engine like Panda3D to the Pi until next week. I have no idea whether the 128 - 128 MB CPU-GPU split leaves enough memory to run a game engine without excessive disk swapping, but, that's one of the first things I'll be looking at, after looking at what it may take to port Panda3D components to run on the Pi. We may find that we need to cut down the functionality to run a reduced-feature engine on the Pi, or it's entirely possible we may wind up only being able to run bits and pieces on the Pi, with other engine resources executing on one, or more, increased-capability systems running on the network.

Due to the Faire demo work, I'm also putting off launching the Pi-finity! team server until next week, but, that won't really be needed until the rest of us finally receive our boards, anyway.

Let's keep the progress moving forward as time allows and keep each other up-to-speed here until the team server is up.

[Wolfpaw]

Is there any sort of documentation about the project objectives, design, goals etc. or has the coding already started?

I'd be interested to know what rules the combat is based-upon, what about classes and level progression, professions, grouping, instancing etc. *before* diving straight-in building the maps.

[PeteX]

Hi Jim,

Thanks for the interesting link to http://glsl.heroku.com/ . Doesn't the shader compiler actually run as part of the browser, rather than on the web server? Certainly watching the interaction with that site (using Firebug) you can see that it is the shader source code that gets downloaded.

It is slightly odd that you can run something C-like in a browser, but of course shaders don't have unrestricted access to memory the way real C programs do.

Are we stuck with dividing the memory in two (for the CPU and the GPU), or do we get to choose the ratio? I could imagine us getting into a situation where 128M isn't enough for the kernel and the game client, but at the same time some of the GPU memory is going to waste. For example, it's always possible (within reason) to save GPU memory by reducing the resolution of the textures, but it might be harder to reduce the amount of code. (BTW, I'm checking textures into Github at quite a high resolution, but that's only so we can decide about texture sizes later. 2048x2048 textures can work with modern PC video cards, but we'll almost certainly need to reduce them for the Pi, I imagine.)

Hi Wolfpaw,

I'd be interested to know what rules the combat is based-upon, what about classes and level progression, professions, grouping, instancing etc. *before* diving straight-in building the maps.

But writing code is more interesting than writing documentation!

Seriously, though... What I'm writing is only supposed to be a demonstration, a starting point for people building their own games. Someone downloading the project should, I think, be able to start the server straight away and see something that works. They get a very rudimentary combat system and three quests or something like that. They can then follow tutorials that let them change the terrain, add new buildings, new quests, and so on. As they get a deeper understanding, they might implement their own combat system and other game mechanics, creating something that is really their own game.

I'm not sure I can or should be giving people an 'MMORPG in a box'. If you were going to write your own game, you'd need to reinvent the game mechanics anyway—otherwise your game would be the same as every other game out there. At the same time, implementing a prefabricated MMORPG would be a huge amount of work if it included all the things on your list.

Don't forget also that some people posting here want to create games that are from completely different genres. Some won't need a terrain at all! To support those ideas, I'd rather avoid baking too many game mechanics into the code.

[Wolfpaw]

Hi PeteX

Thanks for the helpful reply - I agree that coding is waaaay more interesting than documentation

I'd been interested in helping-out. My Pi is on order (like half the planet), but I have a VPS running python which I can use - where's the download available?

Cheers

[Jim Manley]

Per the coding vs. requirements/planning/design/documentation question, I discovered that not everything on the Pi was as i had originally thought, and we can't lock down requirements until we've actually run stuff on the Pi to determine what the limits are to performance based on the available resources. The 128-128 MB RAM split is the only way to get full 40 million polygons/second GPU performance at 1080p, if I understand the configuration options correctly (that's reportedly about four times what an unlocked ~$800 iPhone 4 can do, BTW). Obviously, if we can live without 1080p, that opens up more code options.

Also, we don't need the entire OS stack, so, we should be able to trim back services we don't want eating RAM. We can control what's in memory at various phases of startup, configuration/setup, single-player navigation, (e.g., space/air craft simulations), multi-player interactions (requires shared views of a common scene), etc. We might need to spend almost as much time optimizing things as we do implementing them, which will be educational for students and teachers who may be participating, as well as us.

I didn't look at the Heroku page source to see where the shaders are compiled and I forgot that WebGL is running on the local GPU, so, of course the shaders can run there. BTW, the site allows you to pick your editor of choice to use to modify the shader code. Since there currently is no GPU integration with X window on the Pi, much less a WebGL-compatible browser, that site has to be viewed using a system that does have a WebGL browser. However, that's fine, as the resulting shader code is all that's needed to use on the Pi (as an option, of course).

The good news is that we have the luxury of a treasure trove of code examples to build Pi-finity! upon, or development could easily take years. The bad news is that we have the luxury of a treasure trove of code examples to build Pi-finity! upon, which means stitching together bits and pieces and that can sometimes take more time to get working than expected, especially if the examples aren't well documented. I think we're going to wind up building some things from the bottom up on the Pi and building other things by trimming down a game engine, perhaps initially on a PC/Mac until the resources needed don't exceed those available on the Pi. Then we can tweak things to optimize the entire system.

My intent from the beginning was to develop a set of facilities that are much easier to use to create game elements than the existing code libraries and game engines. Note that I said "game elements", not "games", as I would like to provide as much flexibility as possible so that non-experts, particularly students and educators, can create games/worlds. Documentation would focus on example games/worlds we build so that those in education can expand on our work. One element that Pi-finity! will have that differs from other games is that players will need to do various levels of programming as part of the game play.

I recently saw an interview with a professor at Stanford who has been teaching the famed introduction to artificial intelligence course there on-line for free and the number of students participating world-wide each quarter has been in the tens of thousands, including doing the homework and taking exams. Obviously, grading the homework and exams by hand would be impossible, but, they're using AI software to do that, and we might be able to leverage that in order to provide some level of identifying errors in game players' code, instead of the result just being whether the code runs correctly or not. That kind of facility would certainly have to run off-Pi, but, could be available via a network-connected server. That would be a very long-term goal, but, that should give everyone, including students and educators, an idea of the kinds of modular facilities we might eventually be able to develop.

The journey of 1,000 miles begins with but a single step ... the Pi boards are starting to show up, so, we'll all be able to begin taking those first tentative steps soon.

[PeteX]

Hi Wolfpaw,

There are no releases yet, but you can clone the repository from https://github.com/PeteX/friendlyfruit ('git clone https://github.com/PeteX/friendlyfruit.git'). There are instructions for running the client and server in README.rst. I just realised that the instructions are a bit out of date and they're not in the most logical order, but I don't think there is anything that will mislead you. The main change is that we now have realistic human figures rather than the stick men the instructions talk about.

If you're using a VPS, you should be able to run the server, but you may have problems with the client. Most virtualisation software struggles with 3D graphics at the moment, and if you're accessing your VPS over a low bandwidth link, it just makes matters worse.

Do you know what you want to work on? First of all you have to decide between art and code. On the art side, we're going to need 3D models of various monsters, clothes and equipment for the player characters, and so on. On the code side it's a bit more difficult because things are at such an early stage; at the moment it's difficult finding jobs which are logically distinct and can be split off. What I'll do, I think, is post something on the wiki describing the overall design of the client and server plus a roadmap, then you can see if anything on there takes your fancy. (I'll do that this evening, but I've got to write it, so it won't be there the instant this reply appears on the forum.)

Hi Jim,

Shame about the RAM split, but it can't be helped. If we have to do 720p it isn't the end of the world I suppose—that's what the PS3 uses for games after all.

Agreed about building things on a desktop machine to start with. I think we should always aim to support desktops anyway. There is no reason to insist that people use a Pi.

[PeteX]

I've put the design notes online at https://github.com/PeteX/friendlyfruit/ ... and-Server . If you're wanting to join in with programming, hopefully this will give you a head start understanding the code, and also suggest things you might like to work on.

If any of it doesn't make sense, please ask. I'm feeling a bit zonked at the moment, and I don't think I'm writing very clearly.

[specsdude]

Hi guys-

Is Pi-finity available yet? I'd love to try it out, otherwise if you need any scenery models or stuff along those lines, I'd be happy to model them for you in Blender!

[PeteX]

Hi Specsdude,

It's not available as a finished product, but you can download the current code by cloning the Github repository at https://github.com/PeteX/friendlyfruit ('git clone https://github.com/PeteX/friendlyfruit.git'). If you run this code, you will see a scene that you can walk around. You will be able to see other players but you won't be able to interact with them in any other way. It also only runs on desktops; most of us don't have a Pi yet, and porting the Panda3D game library to the Pi is in any case a substantial piece of work.

It's great that you want to create models; I find modelling much more difficult than programming, so we'll make a good team! Do you have particular models in mind that you want to make? If not, there are plenty of things we will need. We will need monsters! If I was going to choose one, I would go for a wolf I think. (Okay, a wolf isn't exactly a monster, but you get my meaning.) Once we have that as a pattern we can easily tweak it to make other four-legged enemies. For example, we can change a wolf into a panther by changing the textures and the shape of the head—and so on.

We also need clothes for the player model. Currently he's wearing a T-shirt and trousers, which are fine, but aren't really appropriate for a game like this. He also has no shoes! Incidentally, the player model was originally intended more for animation than games, so it uses a lot of polygons. I don't think that matters, though, because most of them will be masked by the clothes. If you load the model, you'll see that there is already a mask modifier that makes most of them invisible, and a load more can go when he gets his shoes.

Finally the trees are okay but use far too many polygons. Like the player model, they are really intended for animation rather than games. This is a more difficult issue that will probably need some programming input as well—we'll probably need at least two levels of detail, and perhaps more.

BTW, buildings probably aren't a high priority. We can get a lot of good buildings from 3Dwarehouse.

[specsdude]

Hey PeteX, call me dave.

About github, how does it work? What should I download...? Also you keep talking about running scripts... I assume you're using Linux, right? because I'm on Windows 7.

So (sorry if i sound like a noob here) what do I have to do to run the game?
and
Where/How do I upload my models? It sounds like you need Collada, which Blender can export... i think.

Anyway, your enthusiasm is very encouraging!

[specsdude]

Pete,

Am currently downloading Panda3D. What would be nice and also helpful/informative for other well-wishing people who find this thread would be a list of things which need to be done/made. Maybe a sticky post, or maybe mention it at Github? But something like that would absolutely top notch. Also I'll see about starting on that wolf!

[specsdude]

Here's my first attempt:



No rigging or textures, except the Clouds one it has now! I don't think it could be re-used as a panther/leopard though!...

[PeteX]

Hi Dave,

The code should run on Windows without extensive rework, but I haven't tested it yet. It's likely that there are a few niggles. I do want the code to be usable on Windows but—since the Pi is Linux-only—it has been a low priority so far. You need to be able to run the game, though, so I'll try to bring it forward. I'm currently in the middle of a rather complicated series of changes, which will allow 3D scenes to be downloaded from the network (rather than the current useless situation where there is just one scene and you can't change it). Once that's out of the way, I'll try to get it working on Windows.

Git is a program for keeping track of program code and related files. It allows people to cooperate on a project without interfering with each other's work. It also keeps track of all the changes that are made to a project, allowing it to be wound back to an earlier state if necessary. You can see more details here but don't worry too much if you find it hard getting set up. I can send you a zip file with the code in it, and you can send me models. It would be a bit more straightforward if you could use git directly, but I don't want technical problems like that to get in your way.

Collada is usable by Panda, but the Blender Collada exporter is buggy and doesn't produce usable output. I get models into Panda like this. You can go through that process if you like, but it might be easier if you just send me .blend files, and let me know which frames go with which animation. Especially to start with, I feel I want you to be free to concentrate on producing good artwork, so I'm happy to pick up the technical issues that go along with it.

Good idea about having a list of things that need to be made. I'll put something like that on the wiki when I get some time.

Nice wolf. (I'm surprised you'd start again if you were making a leopard—I think I'd always rather start with another quadruped and tweak it—but I'm not much of a modeller so what do I know?)

[PeteX]

I've uploaded a list of outstanding projects here, as promised.

[specsdude]

Hey Pete (and anyone else reading this),

update on wolf:



It's now a REAL wolf. It has fur!!(but no teeth!)

Once it's rigged/animated it can be sent off to the Friendly Fruit Labs for processing.

Btw, I downloaded Git and pointed it at the FF git... nothing happened!
Not essential I suppose, but I think it would be much simpler. Plus I could check out the other blend files.

So that's that. Thanks by the way for the Help Needed page, just what the doctor ordered!

Edit: Have just added entry to the Help Needed page, concerning your note:

If you want to work on any of these items, please post on the Raspberry Pi discussion board and leave a note on this wiki

[gladoscc]

Umm, doing this in Python comes off as a pretty bad idea.

1) Py is beginner friendly, but beginners cannot contribute to a 3D MMORPG.
2) Py is slow. We have limited hardware on the Pi.
3) Py does not work well for large projects.

Also, will FriendlyFruit use already existing network communication code?

[Jim Manley]

In pushing through the Panda3D Linux source code (1.7.2) to grok it, I determined that it supports OpenGL ES 2.0 as of version 1.7.0 (the latest Windows release). This is very good news, as I was concerned that we might have to port it to OGLES from OGL, which would require anything but a minor effort.

I'm having trouble getting my board on the Net in that I don't have wired Ethernet access at my current location and, although the driver appears to install correctly, I can't get the the RT73-based USB WiFi dongle I have available to consistently detect any networks long enough to stay connected. I have been taking it to where I can get it on wired networks when I've had time, so, I've been able to download and install some things. That's been eating into my time for working on building software on the board, along with real-world work and life distractions.

Glad to see that you're making progress, Pete, and that others are beginning to participate. The furry wolf is very cool, and reminds me of the out-takes from the movie "Shrek", where the settings for the fur shaders used to create Eddie Murphy's character, Donkey, were out of whack, and he wound up with big, spiky patches of fur sticking out along the normals to the model's polygon surfaces. Eventually, they figured out how to get the fur to lay nearly parallel to the polygons in appropriate directions, but, each of those kinds of models keeps a single animator and at least one software developer busy for literally years getting everything to work across the hundreds of thousands of frames needed in a feature-length production.

Other than becoming familiar with Panda3D and the list Pete has started building and finding/tweaking/building models, there isn't a lot others can do until they receive their Pi boards. One of my co-workers will be receiving his board from Farnell Export this week as part of the last increment of boards in the first 10,000 fabricated, and others are beginning to receive shipment notifications for the next group of boards (of 70,000?) that are apparently coming off the assembly line this week. Once we've either got Panda3D built on the board, or we figure out how to build a useful subset for our purposes, we'll have a much better idea what we'll actually be able to do in Pi-finity! Until that occurs, we won't really know what capabilities the Pi will be able to support, and which features we've been tossing around here will be feasible. I'm not worried much about GPU-oriented things, it's the CPU and RAM intensive tasks that are going to be a real challenge.

We're getting closer to having something to play with on our boards by the time we all have one! Then, it will be a really busy Summer to get enough working for non-developers to start becoming interested.

[PeteX]

Hi Dave,

The wolf is looking good, and thanks for adding the picture on the wiki.

I've never used Git on Windows. If you let me know a few more details, perhaps I'll be able to see what went wrong. There are instructions specifically for Github here. Did you follow those instructions or did you find a copy of Git for Windows somewhere else? Also what happened when you tried to download FriendlyFruit? Did you get an error or did it just do nothing?

BTW if you fork the FriendlyFruit repository on Github you'll end up with your own version of FriendlyFruit. You can add .blend files to the media directory in the copy, then send a pull request through Github when you're ready for them to be added to the main FriendlyFruit distribution. (That is the way you are 'supposed' to use Git and Github, but as I said before, it's your decision. You're very welcome to email the .blend files to me if you prefer, and I'll add them to Git.)

Hi Gladoscc,

Absolute beginners can't contribute, no. Beyond that, I think it's important to distinguish between the core of the game, and developing content. The core of the game involves network protocols, digging around in .blend files, and other difficult stuff. The content is different. 'A player steps on a pressure plate so the monster appears.' The player being in a particular location is an event, and creating a new monster is an API call. Done right, this sort of thing should be a few lines of code only.

You can mod most of the Bethesda games like this, BTW. They all have their own scripting languages—Lua for Oblivion, and I think something custom for Skyrim and Morrowind. Morrowind ran on hardware that isn't so different to a Pi. (I don't know about the Fallout games because I didn't enjoy playing them! )

The low-level code is all C++, actually. Panda3D's Python interface is a thin layer over a C++ library, because as you pointed out, Python would be too slow. The Python code is all high level and 'strategic' so the cost of using an interpreted language is not prohibitive. To be honest I'm more worried about memory use. I've done some measurements using Linux cgroups that suggest we could be okay, but until we have an actual port to the Pi, who knows.

I'm inclined to agree that Python isn't the best language for large projects, but there are plenty of examples where it has been done successfully. Blender is the obvious one, given the focus of this project, but you could also look at Django, Mercurial, and various others. The problem is that we didn't have much choice, given the selection of game libraries that were open to us. The Blender Game Engine is also scripted with Python, so that would have been no different. Gamekit uses Lua, which IMHO is worse. jMonkeyEngine would have given us Java, but I wasn't keen on using that toolkit because it's still in beta.

You can read about the protocol here. It does reuse code, but it doesn't use an RPC library that provides everything out of the box.

Hi Jim,

Good news about OGLES. The release notes say that it is supported (otherwise Panda wouldn't have made my game engine shortlist) but it's nice to have it confirmed! It wouldn't be the first time something was supported 'theoretically'.

I'm glad professional animators have problems with wonky fur, because it's certainly bitten me, and sometimes isn't easy to fix. (A while ago I tried to create a hairy liquid by combining fur with Blender's fluid simulation. I thought it might look cool—it's something you could never have in real life! Unfortunately something didn't work quite right when the two things were combined, and the fur ended up sticking out in all sorts of funny directions.)

There is a difference between animation and games here, though. For example, the hair in Sintel was a physical simulation, as I understand it. You have a lot of strands, then you simulate the effect of gravity and wind. I'm not sure if anyone has tried to do this in real time for games, but we certainly won't be able to do it on a Pi!

[Jim Manley]

BTW, for those not familiar with OpenGL 3-D software, the following link from the book "OpenGL SuperBible: Comprehensive Tutorial and Reference, 5th Edition" leads to a very good introduction to OGL terminology, principles, and basic APIs.

http://www.informit.com/articles/articl ... 6&seqNum=1

Don't worry about memorizing the details, just try to understand how 3-D space is organized, how vertices, edges, polygons, etc., are defined, how models are built up from the GL primitives, how transformations (translations, rotations, scaling, etc.) can be applied to models, and how shaders are used to apply colors, textures, and special effects to model surfaces. It will take a number of passes through the material to really understand everything and that's only necessary if you want to develop software at the OGLES level. The information in this introduction applies almost equally well to both full GL and the ES 2.0 subset that the Pi GPU supports (there are a few APIs and choices for certain features that aren't available in ES).

It isn't necessary to understand OpenGL in order to be able to use Panda3D or Pi-finity!, but, it will give you a much better idea about how 3-D graphics are generated and manipulated by GPU hardware, and what is possible on the Pi. It's all educational, and that's what the Pi is all about, right?

[specsdude]

Hi Pete,

I *think* I've got Git working. I forked the repo on Github.com, then tried cloning in Git Bash on windows:

Code: Select all

$ git clone [email protected]:specsdude99/friendlyfruit.git
Cloning into 'friendlyfruit'...
Enter passphrase for key '/c/Users/David Seeber/.ssh/id
remote: Counting objects: 276, done.
remote: Compressing objects: 100% (186/186), done.
Receiving objects:  38% (107/276), 2.56 MiB | 13 KiB/s

So it looks like it's working, right?...

Then as you say, I can push? pull? the repo back.

How are things going on your end? I understand you're working on the code?

Dave

[specsdude]

Okey dokey! It worked. I now have the whole repository.

Judging from the blends in media, they seem to be set up a certain way. Do I need to copy this method?
Haven't had much experience with games with Blender, usually I just make models to render.

Dave