Programmers

Don't we already have something like this in the coder section of Sumea?

Why not add the links there instead, or haven't you found that feature yet?

To be honest, I had totally forgotten about them, and it took me 10 minutes to find them (for those of you playing at home, "essential links" to the right in the coder section). I don't think they've been touched since they were added how many years ago...

So I'll work on this list and if Souri wants to improve the links section they can go there :)

Why don't you put them there, I filled about 80% of the list there already when it was first started.

It would make sense since you're the "moderator" of the "programmer" forum :-P

Coincidently, I've been working on fixing the section pages, and those essential links will be more prominent and hopefully will be of more use once it's done. It's a bit hidden at the moment, I've been meaning to fix things up for quite a while now.

The coder section doesn't work with Konqueror 3.4.0 btw, it just displays a blank page. Works fine in Firefox.

thats cause Firefox is t3h roxorz!!

I only test with Firefox and IE6, and maybe sometimes with Opera, but only if I'm asking for a headache. I don't know if I can save my sanity trying to support another browser [:X]

It's not that my css code is that sloppy (well, I don't think it is), but it's hard to make it compatible with all the browsers out there which interpret css differently from each other. Firefox seems to have the least problems though.

Everything else I've tried on sumea works fine in Konqueror. I hope CSS with MSIE 6 is better than C++ with MSVC 6 [:)]

It just decided to work btw, though it looks a little strange:

[img]icon_paperclip.gif[/img] Download Attachment: [url="http://www.sumea.com.au/forum/attached/lorien/200542924951_coder1.jpg"]coder1.jpg[/url]
135.92 KB

Let's not talk about CSS with MSIE6, shall we. Thanks. [:D]
I'm guessing the reason why the page was blank for you before was that the old style sheet was still stuck in your browsers cache, so nothing was being seen until the new style sheet explaining where things go kicked in. If there's one thing I've learnt about css's is that they can be stubborn getting out of the cache or refreshed. If you want to upload a screenshot of what's happening in the sumea website related section, I'd appreciate it!

Ahh, ok , I see you've attached it. It's the same problem with the opera browser. It's not recognising the code for transparent background with iframes. The three listings in the page (thumbnails, memberslisting, and the list on the left) shouldn't be having white backgrounds..

Anyway, back to Redwyre's thread of progammer links - please do post your links here. I will add them to the essential links in the programmers section as well.

9 posts, and none of them with links :(

Here are a few then:

http://icculus.org/ (run by a former Loki programmer Ryan C Gordon)
http://enet.cubik.org/ (the enet game networking library)
http://gpgpu.org/ (general purpose programming of GPUs)

hi..

i have been using this tool called GAME MAKER v6.1 and i love it :)

it is mainly a 2D tool, but it can do 3D stuff.. and a good user can make almost ANYTHING with it? (people have made MMORPG's, chat tools, audio players etc)

the best part is that is has drag and drop interface for beginners to make stuff with (very, very simple and a huge active web community) along with its own code / scripting areas for advanced users.. check out the site for more info..
it is a fre download, but a registered version will unlock advanced features.. (but the free version is 99% of the thing anyway!)

http://www.gamemaker.nl/

Ok, I'm unstickying this thread, and moving the links across to Sumea Wiki. You can update and modify the list at: http://www.sumea.com.au/sumeawiki/owbase/ow.asp?ProgrammerLinks

Well templates are really generated at compile time, the compile time of where they are used to be more precise. Therefore in order to have a templated class of some sort (say std::vector) in a library of yours you need to tell it to generate the code for that class. Thus requiring an explicit instantiation, otherwise the template will be compiled when it gets actually used in some other program.

Yeah, but you don't have to do any of this crap on any OS other than windows (it just works), Borland C++ on windows automatically exports and imports templates defined in dlls, and mingw32 doesn't seem to need it either (actually the code won't compile with gcc-3.4.2 on windows).

Are you sure in those cases that the code generated by the templates is actually inside of those libraries, not just inside their headers (and thus gets compiled like a template would normally?).

I'm not sure about mingw, I know Borland does automatically export because there is a commandline option to tell it to do so.

But if mingw wasn't exporting/importing, then iterating over a a vector full of strings returned from a method inside a dll wouldn't work, and it does.

No idea on other OSs, and don't really care, what I do care about is it working.

It wouldn't surprise me if it was re-compiling, but then throwing away the rendundant template instatiations. The whole shared library thing is much better on unixish platforms (though loading plugins is a little strange on MacOSX)- it defaults to every symbol in a .so file being exported by default, and whilst the ability to hide symbols is part of the ELF specification, it hasn't been properly supported by pre GCC 4.0 compilers (the only way you could hide something was by declaring it as static in a cpp file, or putting it in an anonymous namespace).

It hasn't mattered, on unixish platforms shared objects just work without hassle. No import libraries are needed either.

I think BeOS needed identical __declspec stuff to windows, but BeOS is dead.

Returning a std::vector from a DLL would still work even if the instantiated template code was not exported from the DLL. This would be because a copy of the code would be created inside the executable and another in the DLL, and all that would be passed would be the data that they use.

I wouldn't be too surprised if it did the same thing in shared libraries on unix platorms too. Because to you still need to compile against the library's header files when you want to use it. Therefore your code knows that it needs to instantiate a std::vector etc, and it would compile that code into the binary. I guess you'd have to inspect the symbols stored and the code generated for the shared library to be able to tell for sure.

The data types still have to be exported, and this is not a normal string (I know std::string is exported from msvcrt).

It is a std::basic_string, MyMetapoolAllocator > i.e. a string that uses an allocator that uses my memory pool system.

Even then this is a nebulous point: msvc throws out a million warning messages about returning vectors from a function in a dll, it says that it will not work.

I'll try removing my exports and running a test in msvc. Another test would be making a public map member variables in an exported class, and try using it in an exe.

Is it meant to be returning a void pointer?

My suggestion would be to make the void* return value into a parameter that gets passed into the function, and possibly return int or bool from it to indicate a level of success etc.

The other thing to check out would be what you have before that function. Since it could be a parse error from some other section of code that's making the parser confused somewhat.

actually the solution is to make the prototypes LDK_API void* threadLocalGet i.e. the declspec stuff goes first.

It is supposed to return a void*, that's just how thread local storage works...

That static variable doesn't need "api" in front of it (it seemed as though it did with mingw, but that was a misunderstanding on my part). The reson why this thing has to be a macro is because you may want to create Singletons in multiple dlls and exes, so the normal preprocessor trick for handling __declspec is useless.

Right now I'm doing development on Windows CE 5.0 using eVc 4 SP4 at work, although its not the same thing, I do know how much trouble these things can be. My questions would be:
What kind of transports in the Platform manager have you tried?
What cable is connecting your phone to your workstation?
Are you trying to upload your application through eVC itself?

I know that the Microsoft embedded stuff can be a pain to use and get right, even with the emulator and that, so good luck to you getting it working.

quote:What kind of transports in the Platform manager have you tried?
Every possible permutation. If I select the Windows CE device, it connects successfully but I can't select that as the platform.
quote:What cable is connecting your phone to your workstation?
USB that came with the phone, works fine for syncing and browsing the phone.
quote:Are you trying to upload your application through eVC itself?
Yeah, eVC++ SP4 fails as well as VS2003.

Odd thing is that I can't connect to the emulator either, so I dunno what's going on.

Does the phone contain the necessary DLL's as required by each option?
Can you upload files to it using the file browser tool?
Are you using a custom SDK or just the Standard one that came with eVC?
Other than that I can't help too much, at work I'm just using the emulator with a custom SDK.

#include

int main()
{
std::cout << "Write some tools, us artists always need tools, join a MOD, build an engine? But then I'm only an artist. :P
";
return 0;
}

Dean knows code! [:O] man thats 2 'revelations' this week.

Wiffle: Pump out those demos man. Just keepem coming add new functionality to your existing demos or write something new. Start ripping apart every engine and every 'builder' program you can. Read books - programming gems series / game design series. Overall push your skills and absorb as much information as you can on what you want to be and start pushing yourself toward your goals.

yay, nice code Malus hehe.

Hazard: the project so far does bsp-based collision detection as
you walk around a level. My final yr project was a CSG language,
which used flex/bison to parse the language - which are quite
difficult creatures to tame under Win32. There are better parsers
out there now for Win32. Animation is the next step, I just
bought "Advanced Animation Techniques", Jim Adams. I'll start
making a seperate animation project soon before integrating it
with the bsp project. Whether this will be done in time for my
CV I'm not sure yet, but steady, regular progress is the best way.

I'm not a guru (yet) but my advice is finish something.

Tech demos are cool but only half the job, even a small finished project (eg the classic tetris clone) is worth alot on your CV. This includes all the nigly things you hate doing like menus, high score tables etc.

And yes I know how hard it is!

I updated the program a bit recently. I would appreciate any small comments what-so-ever. You don't even need to download the program if 6.5 MB is too much, just visit http://www.smcmillan.net/scenerenderer.html and click on the link to go to the Read Me file. A quick browse of that will give you a fair idea. I mainly just want to know what it looks like I've done right/wrong, whether the program looks advanced or basic, etc.

Thanks for any replies,
Scott McMillan.

PS: here's a picture.
[img]http://www.smcmillan.net/programming_page_files/scenerenderer3.jpg[/img]

heh, cute to see that someone else has debug std::ostream output for there classes, looks neat~ after finishing it, what are your thoughts on code style? that looks a little messy to work on a big project with, but then again, i was not looking at your sample code in a IDE....

Thanks for the feedback.

I have found the code style to be quite good actually, it seems quite neat and easy to follow to me. It's consistent throughout the entire program. The guidelines are documented here http://www.smcmillan.net/programming/scenerenderer/0.9.2/nongenerateddo… . I am open to any suggestions for improvements. So far as I know it's pretty standard though, generally following the style guidelines I picked up in textbooks at university. I figure that the generally accepted conventions have evolved since before I was born and would have reached a pretty good state by now.
There were a couple of things that I learnt the importance of due to this being the largest program I've written though:

• prefixing member variables with m_ is extremely useful when you come back to some code you haven't been working on for a few months. It's even more useful when you don't have the luxury of a nice IDE like Visual C++.
• you need to have standard conventions for naming things such as enum values. If I know a MaterialVertexData enum is going to contain values prefixed with MVD_, I can just type that and press control+space to get a list. Sometimes you can't choose the names you want due to clashes, but it's a lot better than nothing.

Those were the only two things I changed.

And here is a completely stupid and synthetic little benchmark prog

[code]
#define _XOPEN_SOURCE 600

#include
#include "MetaPool.h"

/*
** millisecond accurate timer code for win32
*/

#ifdef WIN32
#include
#ifdef __GNUC__
#ifndef INT64
#define INT64 long long
#endif //INT64
#endif //__GNUC__

#include
#include
#define LARGE_INTEGER_PTR LARGE_INTEGER*

#ifdef _MSC_VER
#define LARGE_INTEGER_PTR LARGE_INTEGER*
#endif //_MSC_VER
static INT64 gDivision;
static INT64 gStartTime;

size_t time()
{
INT64 time;
QueryPerformanceCounter((LARGE_INTEGER_PTR)&time);
time -= gStartTime;
time /= gDivision;
return (unsigned) time;
}
#endif //WIN32

/*
** millisecond accurate timer code for unix
** on x86 Linux gettimeofday is as accurate as
** QueryPerformanceCounter on win32.
*/

#ifdef unix
#include
#include
#include
#include
timeval gStartTime;
timeval gSleepTime;

size_t time()
{
size_t time;
struct timeval tv;
gettimeofday(&tv,NULL);
time = (tv.tv_sec - gStartTime.tv_sec) * 1000;
time += ((tv.tv_usec - gStartTime.tv_usec) / 1000);
return time;
}
#endif //unix

void alignedAllocTest(const int runs, int size)
{
size_t start = time();
void** test = (void**)Memory::alloc(runs*sizeof(void*));
for(int repeats=0;repeats<10;repeats++)
{
int i;
for(i=0;i
void ctPoolTest(const int runs)
{
void** test = (void**)Memory::alloc(runs*sizeof(void*));
size_t start = time();
for(int repeats=0;repeats<10;repeats++)
{
int i;
for(i=0;i();
}
for(i=0;i(t1Runs);

std::cout<<"

";

const int t2Runs=100000;
const int t2Size=10;
std::cout<<"Test2: runs "<(t2Runs);

std::cout<<"

";

const int t3Runs=50000;
const int t3Size=1023;
std::cout<<"Test3: runs "<(t3Runs);

std::cout<<"

";

const int tvRuns=3000;
const int tvLower=16;
const int tvUpper=1024;
std::cout<<"Var size test: runs "<

[:O]

Erm, it looks "neat"... now I just have to look over it properly when I am concentrating in some form of IDE.

[:0]

What are you guys (Hazard and Barry) doing in the programmer discussion area then? [:)] This thing will increase framerates.

I'm just fixing a bug btw: the alignedAlloc function for windows doesn't throw a std::bad_alloc if an allocation fails (doh!)

And another Doh!, an "#include " made in in somehow. Both these things are fixed now.

...so there's a sanity check that the MIN_CHUNK_SIZE and MAX_CHUNK_SIZE are even (your error message saying "must be power of two"), but what actually happens at compile time if they're not powers of two? Do we simply end up with one of those unreadable template error messages, or does it infinitely recurse?

It certainly looks funky - but I'm still confused as to how Pools, Heaps and Chunks really work together. If I'm reading it right, You have 'n' pools, each managing a set of Heaps, and each Heap manages a number of fixed size block of memory (Chunks) ranging from MIN_CHUNK_SIZE to MAX_CHUNK_SIZE in powers of two.

Why the level of indirection using Heaps? What benefit does that give over simply a number of pools of chunks? Perhaps a nice high-level disagram of the data structure would explain what it's achieving...

If they are not powers of two everything should still work (I'll do some destructive testing, thanks), but the 16-byte alignment of every allocation will be thrown off, making it useless for vector operations (I'm doing audio synthesis using SSE intrinsics, and the realtime scripting language, whilst general purpose and pure OO, is designed for audio). The next chunksize will still be calculated by 2* currentChunkSize. Also power of two is a good idea because (on the x86) double precision floats are very slow if not aligned on 8-byte boundaries, and some other architectures just crash without things being aligned properly.

I could do a real compile-time test for power-of-two-ness using another metaprogrammed loop. I probably will if it goes boom when they aren't.

I'm afraid I'm going to have to save the nice diagrams for an academic journal- I need to try to properly publish this because it is very close to a solution to an "impossible" problem of computer science (avoiding the runtime search in memory allocators). I wish I could make it work with languages other than C++ too [:)]
The relation is:
* Heaps manage Nodes, which are headers for chunks. Chunks are where you put your data and they don't exist as a class- they are just ram waiting to be used. Heaps have a fixed chunksize, and by making all Heaps equal in size they can be easily re-used by different Pools when they are empty. This is why the Heap class exists: to pass unused memory around between Pools.
* Pools manage Heaps. Pools also have a fixed chunksize. The Pool class also can ask MetaPool for a spare heap or allocate a new one if the current Heap is full.
* MetaPool manages an array of Pools, each of which has different size chunks.

The goal with this arrangement is to avoid calling malloc or new like the plague. They can have highly variable latency, which is a Bad Thing (tm) for realtime software.

I'm just posting another update, this one has some improved comments, and my CTAssert class was stuffed, it just compiled whether or not the condition was false. Now it prints nice errors. Also I #undef the macros I've defined now.

One more thing, malloc and alignedAlloc functions seem to perform much better on AMD CPUs, it's on P4s that I've seen well over 10 fold performance increase. I suspect it's the stupidly long pipelines in P4s and failed branch predictions. On Athlons the max increase I've seen is around 6x.

Do people think this should be sticky?

Happy me [:D] I've got the only relevent google link to "metaprogrammed memory allocator"

http://www.google.com/search?q=metaprogrammed%20memory%20allocator&ie=U…

i think it should be sticky, i need to re-read it a few time, but with your latter concept explanation post, i think i understand it. very, very nice.

Thanks. I'll have another small update later today.

Update done, changes are the copyright (apparently I share it with the uni, despite much of this code being written in early 2003 before I started), a typo (CTAssert instead of CTASSERT in a 64-bit section), replaced #errors with #warnings if the chunkSizes are not powers of two, replaced #warn (an invalid preprocessor instruction) with #warning, and a few little code style and comment cleanups.

mcdrewski: it does work with non-power of two chunkSizes, but as I said above it's probably a bad idea to use them.

The Heap class serves another purpose btw: it allows Pools to expand without having to realloc. Without the Heap class a Pool would have to hold one big chunk of contiguous memory, and the whole thing would probably need to be copied during a realloc when it filled up. Instead another Heap* is added to a vector inside Pool, and the vector already has a fair bit of space (for Heap*s) reserved to avoid calling realloc or whatever your STL allocator does to resize a vector.

David: I find this code pretty brain bending too, and I find template metaprogramming a little perverse...

Thats pretty damn handy stuff lorien.
I have seen similarly developed ideas for console memory allocation, however none of which cater for the runtime new/alloc problem.
I have seen solutions in Game Programming Gems which use a couple of differing methods, but again, none that cover general purpose use - really great stuff.

I would imagine this would be especially useful for consoles, where their alloc routines are very slow - PS2 is an example I can think of. I'll also try it out on NGage and GBA, and see how it goes.

Another update with a little more metaprogramming. It's documented in the comments. It goes faster :)

Thanks Grover, and thanks Souri for making it sticky.

I actually didn't think it would be good for consoles because of wasted memory because of the pools. Though of course if a near constant frame-rate is important this should be great.

I don't think I can optimise it much more with my current knowledge of c++ and hardware, so further updates are likely to be bug fixes. If you port it to another platform and are not prevented from doing so by an evil NDA please post those ports here and I'll add them to the main code- providing they don't break it for normal computers.

BTW the only "normal" textbook I've seen that mentions template metaprogramming and similar high end techniques is the 2nd edition of Thinking In C++ by Bruce Eckel. It is available for free in electronic form from http://mindview.net/Books

I'm not sure exactly what you mean by 'normal' textbook, but
two good metaprogramming books come to mind;
Modern C++ Design, by Alexei Alexandrescu.
C++ Template Metaprogramming, by David Abrahams and Aleksey Gurtovoy.

Modern C++ design takes alot of traditional design patterns, and
using heavy template code, makes them very safe, flexible, and
easy to use. Alexandrescu's code has problems with alot of compilers
though, it's just too much for them.

C++ Template Metaprogramming is generally a walk-through of the
Boost.MPL library, and showing ways to use it, and how it works.
It's probably good to get a fundamental understanding on how to
actually use metaprogramming techniques. Also, the Boost.MPL library
is quite well supported by a range of compilers, despite it's
complexity. (Quite a feat!)

[edit]

Also, the Boost.Pool library may be of interest in this thread.
http://www.boost.org/libs/pool/doc/index.html

I don't call either of those books "normal", I call them "crazy", but only in the nicest of ways [:)]. Loki (the norse god of mischief) is a perfect name for Alexei's library...
The Boost Metaprogramming library has to be the most complex and innovative library I've ever seen, and I don't even pretend to have anything other than the barest glimmering of understanding of what can be done with it. I've got the book on order.

Be careful asking questions about David Abrahams work on the boost mailing list, I haven't dared for years after copping a real flaming from him- in front of many of the most full-on c++ gurus in the world. I was just asking questions which the docs to his boost::python library didn't make clear.

*****

Sigh, I was completely blind in that update yesterday... There were two conditional branches the instruction stream for a compile time searched allocation when memory was available.

I have reduced it to one, and I simply can't get rid of it :(

These branches are important because they are slow if the CPU's prediction algorithm fails.

Fortunately this one should be quite predictable. It is in Pool::allocChunk().

Malloc/free (which is the same as new/delete) algorithms will commonly have hundreds of branches, many of which are not at all easy to predict. My synthetic benchmark should be showing close to best case for malloc (and the alignedAlloc functions use the same algorithms).

Just posting the update.

This thing I've made is a lot more sophistcated than the boost memory pools: they are single pools for fixed size allocations. This is a general purpose library made up of multiple pools with around the same speed increase as the single pool allocator.

I dug out my copy of Modern C++ Design again, and found the author's name to be Andrei, not Alexei. There seems to be some confusion here, I was sure Alexei was wrong previously, but a google search returned Alexei so that is what I wrote above.
The cover of the book has Andrei printed on it.

I'll post a fix to a nasty bug shortly: having the Singleton::instance method inlined could lead to multiple instances of MetaPool in different translation units :(

I'll have to do some research on the implications of static local variables in inline functions to be sure. The problem could still be there if the compiler decides to inline the method anyway.
The issue code is:
[code]
template
class Singleton
{
public:
static T* instance();
};

template
T* Singleton::instance()
{
static T instance;
return &instance
}
[/code]

From some testing it doesn't seem to be a problem, even in inline functions. It is hard to find info about this possible issue (perhaps it isn't an issue- imho it shouldn't be, but inline functions and static local variables are an interesting mix).

Alexei, oops. I guess I was tired that day, I had the name printed on a book no more than 40cm from me. -_-

As for the static variables and inline functions.. I don't think it would ever be a problem. Since the object is in static-storage space, it would be impossible to compile the program if it generated a seperate additional copy per call, because it would break the ODR (One definition rule) for the linker. (Any workarounds would just be an impossible nightmare - what would their mangled link-names be?)

Local statics in inline functions are a problem when using DLL's. It will create one copy inside the DLL, and another copy for any access outside of the DLL. I don't think it's a problem anytime you are using normal static (early?) binding. So static libs and just compiling into your executable should be fine.
CYer, Blitz

Just posted a huge update. Please use this one because there was a showstopper crash bug in all previous versions.

Docs in this major revision will improve with time.

Perhaps I should make a custom non-template Singleton for this- having seperate memory management between dlls will really stink.

Updated the little stupid and synthetic benchmark too.

This version of the allocator is not designed to give fantastic results in stupid benchmarks. It is designed for much better efficiency in real-world progs.

Just made a very minor update: it didn't build with msvc.net because I'd left out one "template<>" befor a full specialisation. Both g++ and icc didn't complain.

Apparently the msvc.net preprocessor doesn't support "#warning", it tells me "invalid preprocessor command". This means my macro overloading stuff doesn't work on msvc.

For those wondering what mysterious invisible comment I made, I actually unstickied this thread.

I should probably find a better home for this thing anyway: it is becoming multi file.

lorien, please elaborate on how your memory allocator is better than the boost pool libraries.

I once wrote a custom memory allocator class based on the bulk allocator of Bartosz Milewski's 1997 classic C++ In Action. [url]http://www.relisoft.com/book/tech/9new.html[/url]

I can't provide the code as it's owned by my previous employer, but it's basically a single class encapsulating the described behaviour and templatized with an integer which tells it which size objects it can allocate.

The classes which you want to allocate space in bulk for are then provided with an overloaded operator new and delete which calls into the allocator class. This way no other code had to be changed in the 600k line code base.

However, since Boost has come up with a pool allocator library, I'd be likely to check that one before writing my own again. Particularly since it's thread safe and portable.

It's different to the boost pools. I think it's better in the ways that are important to my projects, but I'm not going to say "my code is better than boost", I'm not so stupid :)
quote:
Boost C++ Libraries
#8220;...one of the most highly regarded and expertly designed C++ library projects in the world.#8221;#8212; Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is off the top of my head, please correct anything about boost if I'm mistaken...

The boost pools are single pools. They are not a generic allocation system like this.

The boost pools have a very roughly similar linked list structure to the one I'm using in my Heap class. The difference is the boost pools header structure for an alloc, and the alloc itself are different pieces of memory. Have a look at my Heap and Node class, the Heap allocates a single block of memory, which it splits into Nodes and Chunks (chunks are what I call the actual memory you use) using some nutty pointer maths.

The boost pools let you choose your own memory alignment. Mine is pretty well set to 16-bytes, though it can be hacked.

This allocator is designed to be an insanely fast and reasonably memory efficient full replacement for new and delete, that takes advantage of the compilers innate knowledge of the sizes of all your classes (the metaprogramming). The number of conditional branches in the allocation path is absolutely minimised.

The boost pools are designed to be special purpose allocators for particular types of objects.

My code has changed somewhat since the posts above, I think the above might have a nasty crash bug still... Will release on sourceforge when I'm good and ready, though just ask if anyone want a pre-release. It's part of a much larger low level library with a bunch of smart pointers, STL allocators, singletons, lockless queues etc, etc. Some of the guts of a realtime (low latency audio), multithreaded scripting language split out into a shared library.

One of the big differences between the code above and my current code is I'm using a thread-local singleton to hold the MetaPool class (a thread-local singleton means one instance per-thread).

Making it into a per-thread allocator means there is not a single mutex in the allocation path, and it's completely threadsafe. But you can't allocate memory in 1 thread then free it in another. This condition is asserted for. A gather a lot of JVMs use this optimisation.

This allocator puts a whole bunch of pools together in a vector. The run-time search involves iterating over the vector until the best-fit pool is found. The metaprogramming does this at compile time.

For anyone at a uni here, if you're interested in memory allocators, go to your libraries website and find the database collection. Look for IEEE XPlore and start seaching. It will bring back full journal papers talking about the issues involved in memory allocators. Maybe add "real-time" to the search too.

As far as I've been able to find this is a unique memory allocator.

The library is under the ZLib license, which is basically "do want you want with this, except don't claim you own it". Sourceforge doesn't have the boost license as an option.

Just ask if you'd like more detail, and I'm going to be talking about this at the thing La Trobe runs instead of the AGDC, which is also on Dec the 2nd. Send me a PM if you'd like an invite, and we feed you too [:)] We don't claim it's a conference, it's a chance to see some postgrad and undergrad student work and (if you want) hire some graduates. There will be people from other unis there too.

Edit: it may be dec 3, I'll check tomorrow, though plenty have invites.

It definately looks pretty schmik.
Though without puting it through it's paces (or reviewing code style) I dunno if it'll win you work.

To help exstoll its virtues maybe a table of feature comparison with some other viewers would help it stand out. Or maybe a set of benchmark-type results which show that this viewer handles (fixes?) 3ds files which other exporters/importers/viewers don't.

Some notes on the software design might be helpful too. If I were recruiting coders and I checked it out. I'd be looking for evidence of skill aside from functionality (who's to say u didn't just cut & paste the viewer/importer code from a couple of SDKs (like I would [:P]).

(your link has attached the '.' which has broken it).

But all in all. Cool to have something that you can use to put DX & OGL side-by-side!

people will always try to make money. the sad thing is what people will pay money for

The age of information.

/nuff said.

Not sure if you guys know that there is an archive of the tutorials maybe go get them while you can:

http://web.archive.org/web/20040109222147/www.gametutorials.com/Tutoria…

Cheers
Sam

Just had a peek and it seems that the page is archived but the actual files you need to download are not.

I think it would've been easier to charge for membership and then have free reign over the articles rather than per article. Especially since they're not really their articles, just ones that people have contributed.

Solution: Write some articles for Sumea ;)

quote:Originally posted by redwyre

Solution: Write some articles for Sumea ;)

Now -that- sounds like a very good idea. [:D]

Now which one of you is going to do it?

Considering some of their tutorials were about for loops I am sure even someone who'd read to chapter two in a programming book could do a tut on that ;)

And USF has already done a hello world for us!

Don't know how serious you are, but I might do one on template meta-programming and compile time polymorphism if enough people are interested.

You might as well, it'd be interesting to have it as a reference if nothing else... :-)

I know what you mean, those compile errors from template meta-programming are not nice :(

What I'm working on atm is a meta-programmed memory pool based allocator- it's a container of pools, each of which is specialised for a particular size chunk of memory, and using compile time calculations to find the most appropriate pool to allocate an instance from i.e. getting rid of the run-time search.

So you get something like this

class MyType
{
public:
void* operator new(size_t size)
{
return Allocator::alloc(); //size arg not used
}
};

Of course this means that you would be in BIG trouble if you didn't overload new on every derived class. Still pondering. The pool allocator is done, it's the best way of doing the meta-programming that's taking some time.

The result should be dynamic allocation as fast as stack allocation, and I'm doing it because I'm developing a realtime scripting language where every object lives on the heap.

These accidental features are what keeps c++ interesting [:)]

Compile time polymorphism I might as well do now:

template
class Furniture
{
public:
inline void drawFurniture()
{
reinterpret_cast(this)->draw();
}
};

class Chair : public Furniture
{
public:
inline draw()
{
//actually do the stuff
}
};

How it works:
this Chair : public Furniture strangeness is called the "curiously recursive template pattern". In this case the only thing I'm using the template parameter "Chair" for is so I know in the base class that this class is actually a chair, which makes it safe to reinterpret_cast the this pointer to a Chair pointer, and call methods that are inlined in Chair.

Why would you do this sort of crazy stuff? Performance- virtual functions (and calls through function pointers) can defeat the branch prediction algorithms in CPUs, and the Prescott has around a 30 stage pipline. That means a virtual function call can be expensive. Virtual calls and function pointer calls also present problems for optimisers.

The problems with this technique are:

*Bigger code size caused by more inlining- but caches are only getting bigger
*You can't have an STL container full of Funiture pointers, because each becomes a different type due to the template parameter.

Comments please (and if someone knows how to stop sumea mangling code that would be great)

You can do lots of neat stuff with templates. A personal favorite is this,
used to allow a single base type to be used for derived templatized
types that are passed from the constructor of an object.

[code]
struct DelegateBase
{
virtual void Exec() = 0;
};

template
MethodBase : DelegateBase
{
typedef ReturnT (Object::*MethodType)();

MethodBase(ObjectT& o, MethodType ptr); // Stores method and object.

virtual void Exec() { if (m_Method) m_Object.*m_Method)(); }
};

struct Method
{
template
Method(ObjectT& o, ReturnT (ObjectT::*ptr))
: m_pBase(new MethodBase(o. ptr))
{ }

virtual void Exec() { m_pBase->Exec(); }
};
[/code]

So, this allows us to store:

[code]std::vector methods;[/code]

And still gain the benefits of having the types available when we use the
object.

These extracts from a C#-like delegate, (source available if interested)
and the interface is along the lines of:

[code]
typedef Event MessageEvent; // Takes a string.
MessageEvent OnSomething;

OnSomething += MessageEvent::Function(&PrintMessage);
OnSomething += MessageEvent::Method(Foo::GetSingleton(), &Foo::PrintMessage);

OnSomething(); // Calls Function(string), and Foo::GetSingleton().PrintMessage().
[/code]

Using the above method was required to store a list of the attached
methods and functions bound to the event, and allowing each to have
a seperate return type that is ignored. I'm sure there are many more
cases like this where the technique can be used.

Ignore kalin, he can't code.

I presseded the complile buttons and the compilers says mean things to me about the C++.

[edit]
But really, there are some errors/omissions in the above post.

Method's Exec() is should not be virtual.
'm_pBase' is of type boost::shared_ptr

Probably numerous that I didn't notice, the actual source works,
that's just a snip anyway. ;)

Well the meta-program is up and running, hopefully I should have the whole mempool thing working next week sometime. The meta programming has crazy stuff like this small sample:

[code]
//////////////////////////////////////////////////////////////////////
// Calculate (compile time) the number of pools required //
//////////////////////////////////////////////////////////////////////
template
struct PoolCount
{
enum { value = 1 + PoolCount::value }; //will hold the number of recursions
};

//This terminates the above loop at Size==MinChunkSize
template <>
struct PoolCount
{
enum { value = 1 };
};

//provides easy access to the compile time calculated number of
//pools with noOfPools::value
typedef PoolCount noOfPools;
[/code]

And the syntax used to allocate will be void* mem = Allocator::alloc() , and memory gets freed by an overloaded delete operator. I'll post the full code with detailed explanations (including the runtime pool) in a thread when done.

Anyone got any ideas why the "code" formatter isn't working for me?

Gotta use a forward slash for the closing code tag

ta

Yeah, I wouldn't use templates all over the place normally, but in some cases (where an increase in compile time means a decrease in runtime in a subsystem that's used all the time) I think it is worth it.

Another example is the scripting language I'm making- it's completely full of template code, primarily to make it really easy to extend with new types, and to automate much of the wrapping and type conversion.

Nothing to say

Sounds interesting, might give it a looksee - reading the manual of features, it looks alot like subversion though (subversion has true atomic commits.. and such.)

The local commit sounds promising though, both possibly a benefit and a bane - Not having consistant versions across multiple clients and server could get a bit nasty when commits start to occur - how does the merging get handled with multiple clients committing their largely changed local copies (yes each is atomic, but resolving merges on large local changes would be a little nightmarish)? Would this mean youd have a list of client based branches that would now be in the repository?

That would be my only problem, Im a big fan of subversion with its more strict client/server design. But, I like the idea of a local repository - local versioning control would be handy. Would also be nice to have binary diffs too, currently we have all our projects data and source together in the one repository.

It is nothing like subversion (or CVS). It's much more like BitKeeper or GNU Arch.

How you avoid that sort of mess is by updateting you local copy regularly from a central repository, but I haven't looked into that side of it (yet), I've only been using it on my own.

However BitKeeper manages to handle all the crazy amount of work the thousand-odd Linux kernel developers throw at it, and it uses the same "everyone gets a local repository" model. It just takes really smart merging.

The branches are very different to normal too, every checkout creates one. A commit is a patch against the whole repository, and they are identified by what I think is a 128-bit random number.

You can also pull in changes from other people's local repositories, and because the repository is made up of uniquely identified patch files it won't cause too many problems.

The ataomic commits in darcs come about because of this "commit == single patch file" system.

All I can suggest is try it out. I keep a repository on my home machine, on a master server at home, on my USB key drive, on my work/study machine at uni, and on a master server at uni, and I've had no problems at all keeping them all in sync.

I don't think I'm about to loose any work with that many backups [:D]

BitKeeper is free for open-source projects btw, though it seems a little too much like spyware for my taste.

Hey lorien - big thanks. I have been using darcs for serving / controlling our current game project to my lappy (my main repository now works on darcs and cvs - cvs is required because thats what the US people require). So I have been able to do a darcs get from my home server and do a push we needed to update, and it works flawlessly. The only problems I had with it, was when initially setting up the repository. Some of the binaries I had lying around in some folders caused it to bawk badly - once I found them and commited only what I needed, it has worked flawlessly since.I also realise too, that the binary thing was my fault, since the docs state you should specify binary types in the binary file in the repository.

The plusses over subversion are great - the local patching idea works so well. I also like the autopatch generation and emailing (very handy for team projects). Even the checking and repairing worked quite well (I intentionally damaged some of the repository to see whether it was intelligent enough to fix it :-) ).

Im also working on a specific front end for window for darcs - why? Well, I figure this is an _ideal_ system for art, design and code versioning. The only problem is getting a designer or artist to use another command line tool :-) .. so a pretty interface will hopefully help it get some decent usage with people who dont have time to learn new command line tools. I will post it when it gets completed, might be useful - it is intended to be pretty transparent to use (think alienbrain usage).

I have now switched the majority of my gear over to darcs, and wish to thank you lorien - this is a gem.

I agree it is a gem... I'm NEVER using CVS or Subversion on my own projects again [:)]. Are you using a cross-platform toolkit for the pretty interface?

Yes, my own cross platform gear (since a simple lightweight UI with the components I wanted just isnt available :-) ). Will be using LuaGL that I have posted on Adelindie. Its just Lua+OpenGL + a little UI system I am building - being script its all nice rapid dev, and easy to modify (personalise?). I was even thinking of using a html/xml style display system - thus people can use their fave web builder to make a UI component - will see, the base set of gadgets are nearly complete, then its a matter of data... All operations for darcs will be through script, thus completely adjustable to suit the deployment.

Oh, and it all runs in OpenGL because I wanted something that had a completely consistant interface across platforms, without the hassle of various libraries (like the various toolkits available) and maintaining them and their compatibility. Also, there is an advantage in game development too :-), I plan to build an RPG type D&D game starting sometime in June...

Your screenshot looks interesting. BSP can be a difficult beast to master! So I?m guessing that your loading bounding boxes and getting successful collision detection?

So what engine are you using (or writing your own)?

Anyway, pixel town is now full, but the current activity is pixel class: [url]http://www.sumea.com.au/forum/topic.asp?TOPIC_ID=2211&whichpage=1[/url]

quote:Originally posted by palantir

Your screenshot looks interesting. BSP can be a difficult beast to master!

I had particular trouble to start with by setting tolerance
values too high, resulting in non-terminating BSP division.
It works fine now.

quote:
So I?m guessing that your loading bounding boxes and getting successful collision detection?

The player avatar has an ellipsoidal bounding volume checked
using a simple distance to player origin. This is checked
against the BSP tree of the scene. Collision detection works
great, and even has a 'bounce back' feature.[8D]

quote:
So what engine are you using (or writing your own)?

It's written from the ground up using C++ and DirectX. My
rationale is that once I've written a game from the ground
up, only then will I be entitled to use 3rd party engines.[:p]

I'm currently working on animation and there is scant
documentation to be found. I'm waiting on a book to
come from Amazon called 'Advanced Animation with DirectX',
which might help demystify skeletal animation with bones.

In the meantime there is a bitmap library to be written
for putting up consoles etc.

I've also written a rough UML for message parsing:
MessageUser and MessageQueue. This is the 'observer'
pattern I think.

An agent inherits from MessageUser and has a Brain
and an AnimationDatabase.

More to follow. [:p]

the text mode of .x format with animation enable in the export (and frames/bones enabled) was just a matrix for each frame/node per keyframe... (when i wanted to read this, a simple text parser was sufficeint)

for what you are describing (a series of 'statue' animations) you could just have a .x file of the geometry for each frame, and 'lerp' between two of these geometries for the current animation. perhaps having a custom vertex format with seperate vert_translation into which you can place the 'lerped' vert pos (the uv info wouldn't change, and would be tempted not to change the normals either, just leave them in the original object space, since if it is animating, you may not notice them not reorientate--- movement covers a lot of things)

hope some of that made sence

quote:Originally posted by davidcoen

the text mode of .x format with animation enable in the export (and frames/bones enabled) was just a matrix for each frame/node per keyframe... (when i wanted to read this, a simple text parser was sufficeint)

for what you are describing (a series of 'statue' animations) you could just have a .x file of the geometry for each frame, and 'lerp' between two of these geometries for the current animation. perhaps having a custom vertex format with seperate vert_translation into which you can place the 'lerped' vert pos (the uv info wouldn't change, and would be tempted not to change the normals either, just leave them in the original object space, since if it is animating, you may not notice them not reorientate--- movement covers a lot of things)

hope some of that made sence

Yes it did, and thank you.[:)]

I've been haranguing people on flipcode for close to a month for that info. So I'll make a new vertex structure with a 'scratch' vertex which is constantly changing according to where it is in the lerp. Great. And I'll be able to get the frames from the .x file.

The animation framework for DirectX is there, but docs are scant (I've been searching everywhere). I'm not sure how to access the lerping functions (although I know they exist). I'm hoping the animation using this method will emulate Thief I, using ellipsoid collision objects for humanoids. If that would require more than this method (e.g. skeletal anim.) then i'll stick with this.

EDIT: There is a screenshot of the demo in General Discussion.

Best Regards,
WiffleCube/Heddwyn

Can you post a little more detail. Whats your experience? Done anything yourself previously. How many on your team. got any artwork already done you can show. Got a website with details? Whats the mod about. Whats the story.

my ninja in the exhibition thread is a bit of artwork, ignore the texture though [:)]

I have experience in some java and c/c++ most of my experience is in Visual Basic .NET and C# .NET. I have not currently been in any mods that stayed alive sadly each one I have joined have had horrible leaders. Now I am the leader and I don't plan on stopping the mod for any reasons.

There is about 10 or more people that are currently on the mod.
We should have our website complete this weekend I have yet to hear more news on it.
The Story is still in the works but it's based in Feudal Japan with traditional Samurai and Ninja.

If you would like to read basicly our whole rough layout of the mod then go to:
http://halflife2.filefront.com/news/;10349

Thanks for your interest

hmm read into your mod, found it quite interesting as i was considering writing a thief-style game with more complex swordfighting recently using openquartz or something.. dont have any experience with HL/HL2 modding myself, but have done quite a lot with openquartz, tribes, tribes2, etc.. will look into it sometime once i bother to get my hands on a copy of HL2

normals can be used for lighting, once normalised (if you make a vector(x,y,z) to be one unit long, it is said to be normalised)

if you want to find the normals of a triangle's vertices, then your cross product of (p1 - p0) x (p2 - p1) would give the un-normalised vertex normal....

a normal vector is the vector that is perpendicular to a surface. so, it basically describes which way a surface is pointing, which as davidcoen mentioned is very useful for lighting, especially when used something like normal mapping, can give the illusion of a complex surface from a simple surface. (basically, you have a texture with all the normal information, which can be applied to a surface)

Yea i'm pretty sure i understand the concept behind it but i was having trouble choosing the right vertices to create the vectors. I was getting confused with the "winding order". Tutorials were saying it's important which order you choose your vectors, but i think it's the order which you set your vertices, clockwise counter-clockwise (at least with the example i was working with).

One tutorial i read from gametutorials.com said

quote:The winding order of the vertices determines how you want to create your vectors. If you winding order is clockwise, you want to create your vectors so that the head of the first vector touches the tail of the second vector with a clockwise turn and then cross the second vector with the first.

And then subtracted like this, p1-p0 and p2-p1. From what i gather it seemed to work. Yet everywhere else that i've read they subtracted from the one point e.g p1-p2 p3-p2.

I guess that's where i was getting confused, i think i've got it sorted now.

Thanks for the help though [:)]

It just depends where you want the normal to "face". As if you create the normal with the reverse winding order it will point in the opposite direction. Therefore it's just a matter of figuring out which direction you want to be the front face for the triangle.

quote:Originally posted by Daemin

It just depends where you want the normal to "face". As if you create the normal with the reverse winding order it will point in the opposite direction. Therefore it's just a matter of figuring out which direction you want to be the front face for the triangle.

...and then keeping that consistent throughout the whole world data.

quote:Originally posted by Triton
[code]
----2
---/---/----/-----1_______0
[/code]

When creating the vectors from the vertices my sketchy research has found two different ways.

(p1-p0) x (p2-p1) This produces a normal -z (guess)
or
(p1-p0) x (p2-p0) This produces a normal +z (guess)

Hmmm ok, so i guess my question is what are normals used for?

Sorry for the kindy tute to all the gurus, but hopefully it'll explain something useful.

Well, in nice, simple cartesian (x,y,z) space, the cross product gives you a vector orthogonal to (at 90deg to) the two crossed vectors. If the two crossed vectors are already orthogonal, then the cross product gives you what's called an "orthogonal set" of vectors - ie: they're all orthogonal to each other. An 'n'-dimensional space requires 'n' orthogonal vectors to identify any point in it.

Now, any two vectors (*except two collinear ones) define a plane. The 'normal' to the plane (defined by the two vectors) is the cross product of those vectors.

This means that the normal is just the vector orthogonal to the two vectors you've chosen. In a triangle (the bread-and-butter of 3d graphics for this very reason) you have three vertices (0,1,2 in your diagram), hence three vectors clockwise (p1-p0 , p2-p1 , p0-p2), or three vectors anti-clockwise (p2-p0 , p0-p1 , p1-p2). However, the very concept of clockwise or anti-clockwise means that the triangle/poly you're talking about has a 'front'. The convention is that the normal should also point toward the 'front'.

So, two very simple cases in which it's used:

1) Flat shading. Take the normal generated by the two vectors attached to any vertex, and use that to work out how much light from our light source is reaching that face. Change your colour accordingly (i'm white, but 50% of red light is reaching me, I'll look pink)

2) Backface culling. If i'm looking at a polygon, and the normal is pointing 'away' from me, then I'm looking at the back of the polygon. In most cases, models are built so that backfaces can't be seen (ie: they're inside the sphere/helmet/orc), meaning that there's always a corresponding front-face which will be drawn over the back face. Hence, it makes your rendering faster because you don't need to do all the lighting calculations for back-faces.

Now, "normal maps" and the like are simply ways of saying "you think the normal here is blah, based on the polys, but I want you to pretend that the normal is actually like this. ie: pretend this nice big flat bit is actually pitted like a dried lemon skin. This affects the lighting, and hence the cool facter that we all want.

Please, feel free to correct me gurus :)

sick...count me in! [:D]

What would be involved in this coding comp?

Ok, here's the challenge: Demonstrate the best use of the STL. This will be in the form of a simple program that does a small task while taking advantage of the STL. Here is an example that reads white-space delimed input into a vector:

[code]
#include
#include
#include
#include

using namespace std;

int main(int argc, char** argv)
{
// variables used
vector output;

// push back strings from cin, splits on whitespace
copy(istream_iterator(cin), istream_iterator(), back_inserter(output));

// output to screen
copy(output.begin(), output.end(), ostream_iterator(cout, "
"));

// wait for user to hit enter before closing
cin.clear(); cin.get();
}
[/code]

Programs will be judged on code size (smaller is better), code elegance (keep it clean), and functionality (more bang for your buck). Entries close midnight 31st of December. You may have up to 2 entries. At this point, it will just be me judging. What I say goes.

I see a problem in having prizes for this
This seems soemthing that's probably impossible to judge effectively.

well, then...count me out im afraid...

at this point in time my brain is unable to understand much of the STL...

Oh come on! This is just a fun little comp to help people with STL. The prize is a bonus. I'll post up some examples if that will help some people. Do not be affraid of the STL!

I don't fear the STL, but I've got two games about pirates that need to be made, tons of research and no time.

I'll have a think about something to enter, will be good to catch up on some STL.

i might still enter, i just have to do some research and think of something to make...

I'm in. Can we agree that many of Microsoft's (older) compilers support the STL in a very very bad and nonstandard way, and that if needs be the code can use STLPort, or GCC or similar?

-d

I don't suppose it should matter which STL implementation you use, as long as it's standard conforming code, I guess this would mean no extensions. (And a reasonably new compiler.)

well, after only a short amount of tinkering, i think i can understand how the STL works...

but the competition seems very general, was there anything specific you were looking for? if you could post some more examples that would be helpful.

If i get some time before December 31st i'll give it a crack.

OMG, the possibility of getting a free game! I'm in. Hopefully i can get think up something in the next couple of weekends. Do you want us to just post our entries in this thread?

I put a thread up in the competition section for entries.

http://www.sumea.com.au/forum/topic.asp?TOPIC_ID=2575

It was mentioned that it's not actually a programmer challenge,
but I don't know how to delete the thread. Oops!

Here's a quick one to get the ball rolling, a simple replacement for the standard STL sort algorithm:

[code]#include
#include
#include
#include

using namespace std;

template void merge_sort(T &data, P predicate)
{
T::size_type size = data.size();

if(size == 2)
{
// A single pair, put them in order
T::iterator a = data.begin();
T::iterator b = data.begin() + 1;

if(predicate(*b, *a)) swap(*a, *b);
}
else if(size > 2)
{
T::size_type mid = size / 2;

// Split the data into two halves
T a(data.begin(), data.begin() + mid);
T b(data.begin() + mid, data.end());

// Sort each half individually
merge_sort(a, predicate);
merge_sort(b, predicate);

// Combine the two sorted halves
merge(a.begin(), a.end(), b.begin(), b.end(), data.begin(), predicate);
}
}

int get_random_int()
{
return rand() % 100;
}

int main(int argc, char **argv)
{
static const int size = 20;

// Generate a random unordered data set
vector data(size);
generate_n(data.begin(), size, get_random_int);

// Test our Merge Sort
merge_sort(data, less());

// Display
copy(data.begin(), data.end(), ostream_iterator(cout, " "));
cout << endl;

return 0;
}[/code]
To me the best thing about STL is that it gives you a reliable base on which you can easily experiment with different ideas. It abstracts you just enough that you can concentrate on optimising what's really important, the algorithms rather than individual lines of code. I went for easy to read but my first performance modification would be to make it sort in place to reduce the amount of array copying going on in each recursion. After that I suggest changing to a different algorithm, haha!

• Clean easy to read code.
• All trivial tasks covered by standard STL components.
• Works with any container providing random access iterators.
• Works with any type your predicate can compare.

I tested this briefly on VC++ .Net, apologies for any bugs or incompatibilites.

quote:Originally posted by kalin

I put a thread up in the competition section for entries.

http://www.sumea.com.au/forum/topic.asp?TOPIC_ID=2575

It was mentioned that it's not actually a programmer challenge,
but I don't know how to delete the thread. Oops!

BALETED!

Here is an example that reads words from a file into a set (which is sorted) and outputs them to the screen.

[code]
#include
#include
#include
#include
#include
#include

using namespace std;

class Word
{
private:
string chars;

public:
friend istream& operator>> (istream& is, Word& ch );

operator const string& ()
{
return chars;
}

bool operator < (const Word& rhs) const
{
return chars < rhs.chars;
}
};

istream& operator>> (istream& is, Word& w )
{
w.chars.clear();

// dump non-alpha chars at the begining
while (is.good() && !isalpha(is.peek()))
{
is.get();
}

// get all the alpha chars
while (is.good() && isalpha(is.peek()))
{
w.chars += is.get();
}

return is;
}

int main(int argc, char** argv)
{
// variables used
set output;
ifstream fin((argc > 1) ? argv[1] : "input.txt");

// insert Words from file stream
copy(istream_iterator(fin), istream_iterator(), inserter(output, output.begin()));

// output to screen
copy(output.begin(), output.end(), ostream_iterator(cout, "
"));

// wait for user to hit enter before closing
cin.clear(); cin.get();
}
[/code]

edited:
BALETED!
...I mean fixed closing code tag

How do we enter the competition?
Just post the code up here on the forum?

I'll set something up next week, it will probably be by email.

Here is a simple file copying program.
Usage: "copy output.ext input.ext"

I'll probably try and think up something more complicated later,
but this is a nice simple example of how nice STL is to work with. :)

[code]
#include
#include

int main(int argc, char** argv)
{
if (argc >= 3)
std::ofstream(argv[2]) << std::ios::binary << (std::ifstream(argv[1]));
return 0;
}
[/code]

kalin needs more {}s

Okay, here's one. It does a search and replace on a given text file:

[code]
#include
#include
#include
#include
#include

using namespace std;

/*
redwyre's mini coding contest

Usage:
replace

Replaces all occurances of with in
*/

ofstream fout;

void putwords(string s)
{
// Put words into file
fout << s + " ";
}

int main(int argc, char **argv)
{
list words;
ifstream fin;
string s;

if (argc < 4)
{
cout << "Usage: replace " << endl;
return -1;
}

// Open file
fin.open(argv[1]);
if(!fin)
{
cout << "Couldn't open file " << argv[1] << endl;
return -1;
}

// Read all words into list
while(!fin.eof())
{
getline(fin, s, ' ');
words.push_back(s);
}

// Close input file stream and open output file stream
fin.close();
fout.open(argv[1]);
if (!fout)
{
cout << "Couldn't open file " << argv[1] << endl;
return -1;
}

// Replace oldstring with newstring
replace_copy(words.begin(), words.end(), words.begin(), string(argv[2]), string(argv[3]));
for_each(words.begin(), words.end(), putwords);

fout.close();

return 0;
}
[/code]

To submit your entries, feel free to post them here, but make sure you send them to me via email: xxx with the subject starting with "[Sumea]" I'll try and get everything sorted and announce the winner before the end of January.

[code]
//cache invert sqrt class and testbed

#include
#include
#include
#include

typedef float real;
typedef signed int s32;
typedef unsigned char u8;

struct TCommonCache_InverseSqrt
{
bool operator()(const float lhs, const float rhs) const
{
return (lhs < rhs);
}
};

class CCommonCache_InverseSqrt
{
public:
~CCommonCache_InverseSqrt(void);
bool Clear(void);
bool GetInverseSqrt( const real in_square, real & out_root);
private:
typedef std::map< real, real, TCommonCache_InverseSqrt> TRealRootMap;
private:
TRealRootMap m_root_map;
};

CCommonCache_InverseSqrt::~CCommonCache_InverseSqrt(void)
{
Clear();
return;
}

bool CCommonCache_InverseSqrt::Clear(void)
{
m_root_map.clear();
return true;
}

bool CCommonCache_InverseSqrt::GetInverseSqrt(const real in_square, real & out_invert_root)
{
TRealRootMap::const_iterator iterate;
real root;
bool ok;

ok = true;

if (ok)
{
ok = (0.0F <= in_square);
}
if (ok)
{
iterate = m_root_map.find(in_square);

if (iterate == m_root_map.end())
{
if (in_square == 0.0F)
{
root = 0.0F;
}
else
{
root = sqrt(in_square);
}

if (root != 0.0F)
{
out_invert_root = (real)(1.0F / root);
}
else
{
out_invert_root = 0.0F;
}

m_root_map[in_square] = out_invert_root;
}
else
{
out_invert_root = iterate->second;
}
}

assert(ok);

return ok;
}

s32 main(s32 argc, u8 ** argv)
{
CCommonCache_InverseSqrt invert_sqrt_cache;
real input_number;
real invert_sqrt;
bool loop;

printf("CCommonCache_InverseSqrt testbed: David Coen 041230
");

loop = true;
while (loop == true)
{
input_number = 0.0F;

printf(" please input a number (zero to exit)
");
scanf("%f", &input_number);

if (input_number != 0.0F)
{
invert_sqrt_cache.GetInverseSqrt(input_number, invert_sqrt);
printf(" invert square root is %f
", invert_sqrt);
}
else
{
loop = false;
}
}

return 0;
}
[/code]

ONE DAY LEFT!!

quote:Originally posted by davidcoen
[code]
bool CCommonCache_InverseSqrt::GetInverseSqrt(const real in_square, real & out_invert_root)
{
TRealRootMap::const_iterator iterate;
real root;
bool ok;

ok = true;

if (ok)
{
ok = (0.0F <= in_square);
}
if (ok)
{
iterate = m_root_map.find(in_square);

if (iterate == m_root_map.end())
{
if (in_square == 0.0F)
{
root = 0.0F;
}
else
{
root = sqrt(in_square);
}

if (root != 0.0F)
{
out_invert_root = (real)(1.0F / root);
}
else
{
out_invert_root = 0.0F;
}

m_root_map[in_square] = out_invert_root;
}
else
{
out_invert_root = iterate->second;
}
}

assert(ok);

return ok;
}
[/code]

A little constructive criticism. There are a few ways that I think you can improve your code.[;)]

After performing the following steps:

1. remove unnecessary variables and redundant checks
2. use ternary operators where appropriate
3. use a tolerance value (EPSILON) when comparing floating point numbers to avoid precision errors
4. a little re-ordering
5. recognise that it always returns true and make the function void
6. add comments!!!

The code above appears to reduce to:
[code]
void CCommonCache_InverseSqrt::GetInverseSqrt(const real in_square, real & out_invert_root)
{
TRealRootMap::const_iterator iterate;

// assert that a real root exists
assert(in_square > EPSILON);

// some comment
iterate = m_root_map.find(in_square);

// some comment
if (iterate != m_root_map.end())
{
// some comment
out_invert_root = iterate->second;
}
else // some comment
{
// output inverse of root
out_invert_root = (real)(1.0F / sqrt(in_square)));

// set inverse value of root in map
m_root_map[in_square] = out_invert_root;
}
}

[/code]
The EPSILON checks may be unnecessary if the "real" class (template?) handles precision checks (I wasn't sure, I usually code in C).

Update: I got rid of a ternary operator and the check that the root is valid. If in_square is greater than a well-conditioned threshold (EPSILON), the root should be valid... I think that this is a reasonable assumption...

//Display Hello Message
#include

using namespace std;

int main (void)
{
cout << "Hello World" << endl;

return 0;
}

LOL USF! That effort earns a prize in my book [:D]

Hehe ? USF ? first you bring us programmer art, and now artist programming! Brilliant!

HAHAHA!!! That reminds me of my first C++ Game!

Funny [8D]. Have you contacted any publishers yet?

In seriousness the recorded states of your uhh 'actor'
is a good way to go. If you were to translate that
humour with some graphics it could be a cute bit
of shareware.

Yep DirectX 9 is still using the DirectX 8 input. Thats the latest version.

sick as...thanks Mdobele

(a) This would probably be better off in the Job Discussion forum.

(b) Just send in some examples of your mod work - if it's programming. I'm sure they'd like to see what you've done. And if you've already applied then there isn't enough time to write a whole demo from scratch.

Forgot to mention.. you may get slightly different results each time you take a measurement... this is due to other processes being executed.

As an aside, the MVC++ inline keyword is not just syntactic sugar. During
disassembly I found that taking it out causes a function to be 'called' whereas leaving it in puts it straight in the execution flow.

For timing code on Windows computers just use the built in high resolution timer, it's that simple. And you're using __int64 there which is IIRC a Visual Studio keyword, not a GCC one.

It might be useful for Linux and other operating systems running on x86 hardware. However generally now I try to stay away from doing assembly stuff in my programming, it really isn't worth the effort for anything more than a consoles.

Yeah, you can just use QueryPerformanceCounter etc. on win32 systems and that way you don't even need to do any checks to see what the CPU is, the Query function will just fail if the CPU doesn't support it.

But anyway, the benefit of using expensive profilers is not the timing, but they usually give you nice information on a function by function basis for the entire program, without having to insert any additional code in your program. At least thats what i read/hear :P

"As an aside, the MVC++ inline keyword is not just syntactic sugar. During
disassembly I found that taking it out causes a function to be 'called' whereas leaving it in puts it straight in the execution flow."

Yup, thats what it's supposed to do :P
And "inline" is a C++ keyword, not MSVC++ specific...
CYer, Blitz

It's good that you can do that wrapped up in a call. Didn't know it existed, or how it's implemented. If it clears the pipeline beforehand it'd be useful for measurement, but if it
leaves stuff there then the code your trying to tighten up might be measured inaccurately.
I wouldn't advocate writing everything in assembler, but timing allows different C++ approaches
to be compared for e.g. cache coherency etc.

On the subject of the 'inline' keyword, of course it's a standard C++ command, as is 'reg', but depending on your compiler they may or may not do anything. In MVC++ with optimisation turned on forgetting to inline code sometimes still results in a call-which is quite surprising. Probably some flag settings I missed.

There are compiler options in vc++ to turn inlining on/off (should be under c/c++->optimisation->inline function expansion). The inline keyword itself is only a hint to the compiler anyway, the compiler can still choose to not inline code that you have specified as such.

"In MVC++ with optimisation turned on forgetting to inline code sometimes still results in a call-which is quite surprising. "

Are you talking about code that you have implicitly inlined by defining it inside the class declaration? If so, then it's probably a case of what i stated above, compiler decided the function wasn't worth inlining. If it's a function defined outside the class, then afaik VC++ will never inline that code unless you give it the inline hint...
You can use the MSVC++ specific "__force_inline" directive to give the compiler a very strong hint that you want certain code inline.
CYer, Blitz

There is one case I know of where inlining actually made the code go slower :) It was under the BeOS, running on a bebox with 2xPowerPC 603e processors - the L1 cache was something like 16K for instructions. It turned out that what was happening was that by inlining this particular function (which was (A) long and (B) had been used in many other parts of the code) it forced a loop to bloat to well over what would fit in cache, hence lots of cache misses :) (The program was calculating Pi or some equally nerdly pursuit...)

Ah now there was a cool case mod that was ahead of its time (the LEDs on either side of the case showed the processor load):

[url]http://www.litmusgreen.com/ed/bebox.jpeg[/url]

Blitz: That's useful to know, especially when your trying to keep the execution sequence branchless.

Combat Wombat: Looks good, got to admit I've never really got into hardware, mainly I think because of squeamish; all that exposed hardware reminds me of an operating theatre *shiver*

Regarding the RDTSC instruction, you need to remember that it might not work as intended in multi-processor environment. For that you'll need to keep track which CPU is executing the RDTSC instruction. Also, there is a chance that some OS' don't allow the execution or RDTSC, which causes the CPU to triggering an exception.

The longest part of writing a text-based adventure, is going to be creating the game data, not the engine.

Provided you design the "engine" to be generic enough from the beginning, you should be able to code it early on, and spend the remainder of your time creating game data (without the need to go back to the code and add features etc).

You could easily code this game in C++, although I can't see there being too many levels of abstraction / classes etc in a text-based adventure.

I haven't played THGTTG, so I'm not sure what that was like. What sort of "feel" are you going to give this text-based adventure? Will it be the classic "room"-style adventure, where each room has a description, a number of exits, some items etc? That system becomes quite easy to represent: Have a class for a room, which contains a linked list of exits, a linked list of items, a linked list of opponents etc. You'd probably create classes for each of those things, too (exits, items, opponents - exits could simply be a pointer, though).

It wouldn't be unrealistic to store the entire world in memory, along with each item etc.

There's bound to be quite a bit available on the web - if you're going with the room-based system, MUD's (Multi-User Dungeons) are on a similar path, although their source is likely to be overly complex dealing with the multiplayer issues.

Is C++ the best choice for this 'text-based' game?

I would have thought Java with Web Start deployment would be the optimal choice.

I remember GameTutorials.com had a few tutorials on this. Ah yes, he we go:

http://www.gametutorials.com/Tutorials/GT/GT_Pg1.htm

Stephen: C++ may not be the best choice, but he's wanting to learn C++, and is planning use this as an exercise to further that knowledge.

What file format is the model saved in?

I'd love to help but unfortunately any simple run-time I could create at the moment would only be able to read my own custom xml format. Haven't gotten to looking at supporting 3rd party formats yet.

Also another downer is that my engine can only render triangle strips with a single opengl material, no texture's as of yet.

That's probably a bit limiting for you.

Thanks,
Stephen

Hi Stephen,

Thanks for the input, I would prefer something that could use .xsi format if possible.

Something like ATI's normal map viewer is the type of thing I'm after, it'd probably do the job if it supported environment mapping.

Edit: I just found this http://www.quick3d.com/index.html and tried it out, looks like the type of app I was looking for.

Are they using lightwave objects/scenes by any chance?

quote:Originally posted by Souri

Are they using lightwave objects/scenes by any chance?

I think the site said that Lightwave file support was currently in the works.

I downloaded the 4x4 model to try and I wasn't too impressed with the framerate after bumping up the texture resolution, (I ran it on a high spec machine) especially since the model was only 12k tri's.

oops, I meant are you/your client using lightwave. And I just missed the bit where you said .xsi [:)]

Hemiware had adjusted their serenity engine into a viewer for a client. It loads a lightwave scene (animations and all) and renders it in realtime. So if your scene was a camera fly through or whatever, that's what the engine would render. I had a look and it's pretty cool, and it would seem perfect for you, apart from the fact that I don't think SoftImage files are supported.

Well, as a matter of fact my current system does already do alot of what you need. Could also easily add UI to select between the different decals and such. All of it runs in script, so there is no need to recompile or build the exe to add features. I dont support XSI at the moment, but I think I can provide it (I have an old XSI exporter I worked on a few years ago) if you really need it - would only be a day or two to add. I would however, obviously charge for use of the engine.

If you are looking for a free option - try out Nebula 2 or Nebula. Its totally free, and there are viewer scritps already available for it. It shouldnt take more than an hour to get a car doing what you want in it.

Hope this helps.

That's a pretty good idea, I haven't heard of it being used like that before, but someone else has probably thought of it :)

I'm not sure if it would be worth it though... you only need ~6 triangles to make a thin cylinder, vs the extra overhead of normal mapping and processing to work out the 4 points based off the 2 end points (which would probably need special casing, adding bloat to the pipeline).

It would probably be easier just to create the lamp post using ~50 polygons with a texture or two rather than making a sprite (which it is). That is on current/newish PC technology, however on the consoles this still might be a good idea, however I don't know how expensive normal/bump/displacement mapping is on them. I would imagine quite expensive on the PS2.

i would love to be goon enough to make a simple test to benchmark this,.

i guess the construction of the plane per frame would be a bit much. esp for multiple adjoining segments. even so !! i love the thought.

even if its not good computational wise i would still like to see if it has any benefits over regular cylinders, beauty wise.

Just throwing thoughts around, but you could probably make it so you didn't have to do any re-calc per frame. Instead, you'd write a tool to pre-calc it all before hand, and store it in you map file (etc). Anyhow, if you were to create the normal and displacement maps so that the one image contained the pixel information for the full 360 degrees, you could apply it to the plane in an environment-mapping sort of way (heh, real bad explanation there).

Basically what I'm getting at, is that only a portion of the entire texture would be mapped onto the plane at one time, and this portion would differ, dependent upon the direction of the vector from the camera to the plane. That way there'd be no major per-frame calculations, and the effect could be pulled off quite effectively (I think).

This would only work for objects that are uniform around one or more axes, but then it would break down if we were looking at it from above or below...

Also I don't know how well it would blend from polygonal geometry to this sprite based one...

Although using a displacement mapping technique like this could be applied to make voxel type landscapes in games now I reckon. I think the game Perimiter does something like this...

you couldnt use a sprite for this as looking at it from above or below hanges the shape of the object

it would be a polygon rectangle that rotates around 1 axis so that it is always perpendicular to the viewer

there would also be the overhead of making the algorithm connect the edge vertices of a multiple segmented cylinder ie something that isnt straight like a lightpole or a torus

This is kind of similar to what Phong shading does. The reason Phong shading isn't widely
used for real-time graphics is because it's computationally expensive to recompute so many
normals; one of the reasons polygonal/boundary representations (B-Rep) are used is because
it is relatively cheap to fling them onto the screen.

Theoretically you could make a set of stairs out of a single rectangle using bump-mapping,
but it would be a lot neater and computationally cheaper to use a bunch of different sized
boxes welded together instead.

The two main things (apart from hubris and opportunities for laziness)to be at the front
of the mind of a programmer when designing algorithms are 'How much does it cost in terms
of time/storage compared to another method?'. Most algorithms courses will leave you with
these notions firmly burnt into your mind!