Jump to content
  • Advertisement

Knarkles

Member
  • Content Count

    999
  • Joined

  • Last visited

Community Reputation

271 Neutral

About Knarkles

  • Rank
    GDNet+
  1. Knarkles

    Help needed

    Ok, more pieces to the mystery puzzle: someone got it to compile with GCC 4.5.0 / Linux / x86-64, no errors. I'm starting to suspect it's a combined GCC 4.4 bug and MinGW linking problem, not a single error manifesting in two different ways.
  2. Knarkles

    Help needed

    While PyEigen 0.2 is mostly ready for release, I'm stuck on weird problems with GCC on both Windows (MinGW) and Linux. PyEigen compiles fine on Visual C++, but GCC gives different errors depending on the version. On GCC 4.4 I get these mysterious errors: source/iterator/matrix2fiterator.cpp:39: error: insufficient contextual information to determine type source/iterator/matrix2fiterator.cpp:40: error: insufficient contextual information to determine type source/iterator/matrix2fiterator.cpp:41: error: too many initializers for 'PyTypeObject' On GCC 4.5, apparently every template function in PyEigen results in an undefined reference, even though the implementations are (or at least should be, as MSVC finds them) included in the object files. Frankly I don't have the faintest idea why this is happening. I even completely restructured the code to try if the (admittedly confusing) header relationships were to blame for the errors, but nothing changed. If someone wants to help (pretty please) and try to figure out what's wrong, you can grab the code here: http://code.launchpad.net/~knarkles/pyeigen/trunk. You need the Python headers and Eigen 2 to compile; feel free to ask me for help on getting a build setup up an running.
  3. Knarkles

    PyEigen 0.2 feature complete

    After a couple of weeks of hiatus, the 0.2 release of PyEigen is now feature complete. What's left is some testing and documentation, then release. I postponed quaternions and transformations to 0.3 because variable-size matrices were plenty of work for a single release and single programmer already; I don't want too much time between releases at such an early stage. If I'm not too busy, PyEigen 0.2 should be released in a week or two. I did some benchmarking on 1000x1000 matrices. Insanely, enabling SSE2 instructions speeded up that test case by 10x; I was expecting a 4x increase at most, since SSE instructions handle 4 times the data per instruction. NumPy is slightly faster for 1000x1000 matrix multiplication, but there's an obvious optimization in PyEigen that will hopefully make it faster again. That will have to wait for 0.3 though, since it's a bit tedious to implement. For those interested: there's an extra matrix copy in all PyEigen functions and operators that return a value, which I can probably optimize away. BTW, if you want more frequent progress updates, you can follow my Twitter feed. [smile]
  4. Knarkles

    PyEigen 0.2 teaser

    I just want to assure everyone that development of PyEigen didn't stop at the 0.1 release and I've put many hours into the next release already. I have almost finished rewriting everything using C++ templates; might as well take advantage of C++ features since Eigen requires a C++ compiler anyway. Lines of code have been cut almost in half and maintenance will be much easier in the future. Here are some of the major upcoming features (subject to change, completed features will be in bold): Python 3 support Matrix iterators & slicing Variable-size vectors and matrices In other news, I just found about PyBindGen, which looks very promising compared to other binding generators, and might be worth checking out for a future version of PyEigen. Can someone speak for or against it? I'm mostly worried about performance, since I want PyEigen to be as fast as possible; after all, that's the sole reason I started the whole project. Update (2010-03-30): Matrix iterators done, slicing dropped (you can just convert to a list first). Update (2010-05-03): Quaternions and transformations postponed to the next release, variable-size matrices done.
  5. Knarkles

    PyEigen 0.1 released

    Thanks. :) I hope it will! Yes, I'm using Bazaar, and I'm finding it very good, especially combined with Launchpad's project management. Creating and merging branches is trivial compared to eg. Subversion. If someone wants to make another branch (say, like Moguri did for Python 3 support), it's just a matter of creating a Launchpad account and just, well, branching the trunk. The new branch is even automatically shown on the project page without me having to do anything or grant any permissions etc. After that, I could easily create a new plan ("blueprint") for Python 3 support, attach the branch to it and add it as a goal for the 0.2 release. Easy peasy.
  6. Knarkles

    PyEigen 0.1 released

    PyEigen 0.1 has finally been released! See the (still) very limited blog page, grab it at the Python Package Index and get involved at the Launchpad project page. Here's the announcement: I'm happy to announce PyEigen, a new linear algebra module for Python that's many times faster than existing solutions. Notably, PyEigen is about 10x faster than NumPy for 4x4 matrix multiplication and 4x faster than cgkit 1.2.0, the fastest current solution. Python Package Index: http://pypi.python.org/pypi/PyEigen/ Launchpad project page: http://launchpad.net/pyeigen Development blog: http://www.brainfold.org/blog About PyEigen is a Python wrapper for the C++ linear algebra library Eigen. PyEigen is currently considered PRE-ALPHA quality software and has not been widely tested outside the unit tests. The API is not stable yet and might change between releases without warning. Testing and all kinds of feedback are welcome however! Compatibility reports with different operating systems, compilers and Python versions are especially welcome. Features The first release of PyEigen includes basic support for fixed-size vectors (2-4-dimensional) and matrices (2x2, 3x3 and 4x4).
  7. Knarkles

    PyEigen progress

    Development of PyEigen is going really well. All the features I want for a 0.1 release are basically done and there's just testing and documentation left now. For version 0.1 documentation I'll just write some docstrings and a readme file, but I want full unit tests for the module. Vectors and matrices are really low-level stuff and writing C code is quite prone to errors, so I want to make sure everything works and it can't be crashed. I'd say you can expect a first release in about a week. It's going to include support for fixed-size matrices (2x2, 3x3 and 4x4) and column and row vectors (2-, 3- and 4-dimensional). Major game development -related features missing include transformations and quaternions; they are probably coming in the 0.2 release along with coefficient-wise (aka element-wise) operations. I'll probably add support for variable-size matrices and vectors later. Compatibility with ctypes and NumPy would probably also be useful. Feature requests are welcome. [smile]
  8. Knarkles

    Engine Status: Ready to rip.

    Sounds good! I'm still disappointed you're not going to make Skirmish for the iPhone though. [grin]
  9. Knarkles

    More types and results

    I implemented some new types for PyEigen, including a 4x4 matrix class and benchmarks for it. Same methods as last time, but quite different results. PyEigen is still fastest by far, which is promising. This time it was about 5-10x faster than cgkit1, which was again the second fastest. You might also notice that vectypes is missing. For this test, it was so slow that I had to leave it out; other results would have been invisible if I had fitted the vectypes results in the graph. In the worst case, it was over 1000x slower than PyEigen! Euclid is missing addition and scalar multiplication scores since it doesn't support those operations. NumPy performed much better. There has to be a faster way to do vector cross product in NumPy, since matrix multiplication was much faster than cross product. But it's not a big deal anymore since PyEiglet is so much faster than anything else. [smile]
  10. Knarkles

    Surprising results

    I did some preliminary benchmarking today and got very interesting results. I have only wrapped a 3D vector class so far, so I tested a couple of operations (add, multiply, dot & cross product) against the libs I mentioned in the previous post: NumPy, euclid, vectypes and cgkit. For cgkit, I tested both 1.2.0 and 2.0 alpha 9. All other libs were the latest version. I tested using the Python timeit module with 1,000,000 calls and 3 repeats per test and took the lowest number. Repeated test results generally differed only by milliseconds. The immediately obvious surprise is the abysmal performance of NumPy especially in cross products. I don't think NumPy optimizes for fixed-size arrays; I would have been better off with the pure-Python euclid and vectypes modules. The other surprises were euclid vs vectypes and cgkit1 vs cgkit2. Euclid and vectypes are both by Alex Holkner of Pyglet fame. In both cases, the newer library (vectypes and cgkit2) was also slower. Of course the most positive surprise for me was the performance of PyEigen. It's only a trivial wrapping, but was about 2-8x faster than the best alternative, cgkit1. I'm very happy with the results and definitely going to continue development of the library / wrapper. [smile]
  11. Knarkles

    PyEigen

    Oops, looks like my GDNet+ subscription ended without me noticing. I'm back now. Anyway, I have a new project called PyEigen, a wrapper for the C++ linear algebra library Eigen. I just submitted the first batch of code and progress is good, at least so far. [smile] I'm hoping for an initial release within a month or so. The whole thing started when I profiled my shooter project and found that matrix calculations take up a huge amount of time. Apparently NumPy isn't really fast enough for 3D games, and I couldn't find any replacements. While otherwise looking good, euclid and vectypes are pure Python so they aren't going to make performance any better. cgkit is C++ with a Python wrapper so looking better already, but... it's using Boost.Python, which apparently isn't very fast. Also, it's lacking SSE instrumentation and other optimizations included in Eigen. So I decided to wrap Eigen. As I already found out, Boost.Python is slow and looked too complex for such a simple library anyway. I tried Cython next, but its C++ support is (still) very limited and the lack of support for C++ references destroyed any hope of wrapping Eigen, which relies heavily on them. My final option before resorting to manual wrapping using the Python C API was SWIG, but I had problems getting even a simple wrapper to compile. Besides, I don't really like how SWIG generates function wrappers and a separate Python module that calls those wrappers instead of generating a Python C module directly. So I was left with only the final option: Python C API. I feared it at first because I've never worked with it and it seemed really complex. It is complex, but not nearly as bad as I though, especially as Eigen has such a simple API. For Bullet, I'm sure I'll use Cython or some other wrapper generator, but for Eigen the Python C API is just fine. Anyway, since there doesn't seem to be anything like this out there, I decided to make it an open source project so hopefully other people in the same situation won't have to jump through the same hoops as I did. I'll post progress reports, releases and especially benchmarks against the other options as soon as I have them.
  12. Knarkles

    Stealth prototyping

    Yes, I know, I have been quiet on this blog for over half a year now. That doesn't mean I'm dead; quite the opposite, since I have been really busy with Real Life and professional game development. [smile] However, as some of you might have noticed from my Twitter feed, I have been working on a new game. It started as a vertical-scrolling shoot'em'up but has transformed into something else entirely. At the moment I have just a load of ideas and an early prototype, so I don't want to write too much about it yet, but more on the project later. And yes, it's in Python. [smile] As for Artillery Brawl, the code became a mess and destroyed my motivation to continue the project, which is why I started the new game to begin with. I might start Artillery Brawl again based on this new codebase, but for now I'm working on the shooter. I hope to write more about the new project and its progress again in the near future, but in the meantime, the best way to follow the project is my Twitter feed.
  13. Knarkles

    Holy hitboxes!

    Yay for progress! (as opposed to some of us ;) Coincidentally, my job is also somewhere between application (game) code and UI, though I enjoy the UI side more than the application side. :)
  14. Knarkles

    Work!

    Quote:Original post by evolutional Well done! Any tips for someone wanting to move that way themselves? Connections. [smile] I wouldn't have the job without a friend in the company who spoke for me. Otherwise, just lots of experience and somewhere you want to be in five years; for me, it's user interface design, so I got a job as a menu programmer.
  15. Knarkles

    Work!

    My latest excuse for not getting anything done on Artillery Brawl or any other projects is that I just landed a job in the game industry! I didn't want to announce it on the blog before I got a contract, but today I got one as a programmer for Bugbear Entertainment. It's interesting and kind of refreshing to seriously program in C++ for a change.
  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!