semi/signal

From NextGen,

Ubisoft plans to make the sequel to Beyond Good & Evil more “accessible” than its predecessor, in order to avoid the commercial shortcomings endured by the original.

Apparently, Ubisoft evaluated the original and somehow came to the conclusion that difficulty was the reason the title flopped at retail. Maybe, but from the comments garnered by the article this doesn’t seem to be the case. Also, I dug up the old gamespy review and “low difficulty level” is actually listed as one of the cons.

Well, here’s another explanation, the reason I didn’t buy the game was that I played the demo: great characters, interesting environments, etc., but I had the game crash or freeze on me multiple times to the point where I just gave up and didn’t bother even finishing the demo. Now, this may have just been an issue with the demo, or maybe the PC version, or a graphics driver issue but, simply put, the demo left me with a very negative impression of the game’s technical quality and even now, when I pick it up for far less than the initial $45+, I’m apprehensive to do so. Maybe this was just my experience, but it certainly seems to be a more plausible factor (among many others) than difficulty.

As many already know, the Pheonix lander touched down on Mars a few days ago. It’s a great feat of engineering and it’ll be exciting if we find life under the permafrost. However, aside from whatever scientific value they may hold, I’m not really fond of the pictures from the lander or the rovers. While there is something eerily cool about seeing the surface of another planet, Mars is (1) not a very pretty planet and (2) the cameras can only give a very close-to-the-ground shot of the landscape (the flat, rock-covered, brownish-red landscape).


That being said, one of the coolest images I’ve ever come across is below; it’s an artificial cloud formed from the gas of the rocket used to launch the pheonix lander.


I also love the colors and how they blend together, as well as the “texture” of the clouds. I’m thinking this might be a great texture and color scheme for the design of a web site or GUI widgets or something… I don’t know, it just looks damn cool.

Full resolution images available at the Pheonix Mars Mission site.

I stumbled upon an annoying little graphics bug recently where I was getting corrupted textures on a Radeon 9500 graphics card. I eventually came across this thread which hinted at the problem. Apparently, automatic mipmap generation is messed up on the Radeon 9500 and screws up your textures (I got rainbow colors, weird blocks, etc.). I’m pretty sure the hardware supports it, so perhaps it’s a driver issue, but in any case it didn’t work.

What’s even more annoying about this is that everything worked perfectly on a much older Radeon 7500 card.

Well, of course, you can edit php.ini to change the file size limit, but for cheap (typically, shared) hosting solutions the issue that pops us is that you don’t have access to it.

I was researching how I could do this w/o modifying php.ini and discovered a forum post that explain a few methods of how it could be done.

Method A (the one that worked for me):
Edit your .htaccess file (if you don’t have one in your web site’s public root directory, you should be able to just create one) and add the following:
php_value post_max_size 8M
php_value upload_max_filesize 8M
(of course, replace 8M with however many megabytes you wish to limit the file sizes of uploads by)

Method B (the one that didn’t work for me):
Use the ini_set function,
ini_set('post_max_size', '8M');
ini_set('upload_max_filesize', '8M');

Method C (the one I didn’t try):
Use a custom php.ini. Not sure exactly what would be involved here, but you’d likely have to programmatically make a copy of the existing php.ini file, modify the copy, and then place the copy in the directory of the script that needs it or in your web site’s public root directory.

Compiling WebKit on Windows is far from trivial. In the process of getting it compiled and linked successfully, I took some notes which may help others struggling to getting it done.

First, a few precautions, don’t try to be smart. Follow the instructions on the site closely, this means:

• Don’t try to compile w/ Visual C++ 2008, it won’t work. Use VC++ 2005.
• For VC++ 2005 Express Ed., make sure you have SP1, compilation will fail w/o it.
• For Vista, make sure you have the additional SP update.
• Don’t try to compile outside of cygwin directory structure.
  

Next, you need to get the webkit source.

• Get the source from a nightly build (make sure to download the source and not one of the platform specific builds). You can also get the files from the subversion repository, but I had issues with this and discovered missing files. It may have been fixed, but in general, I think just getting the nightly build is simpler.
• The source is in a .bz2 file. So you’ll need a bzip2 decompressor.
  
• The bz2 file decompresses to a .tar file (wtf?!), so you’ll also need a tar decompressor.
  
• Next, download the WebKit Support Libraries.
  
• Put the source under your cygwin/home/<username> directory (e.g. \cygwin\home\<username>\WebKit)
  
• Finally, update, by running the update-webkit script.

Preparing for compilation.

Note: I tried to build from the cygwin shell, as demonstrated on webkit.org, but it failed. Failing in this way and then having to dig thru build logs is insane, so I diverted to building from within VC++ so I could easily spot and fix errors as they occurred.

Note: I failed to realize that I didn’t have SP1 for VC++ 2005 Express when I started this whole process and didn’t figure it out until I hit a few perplexing errors related to the linker failing because it detected different versions of the compiler were used for the 2 parts of compilation on a few object files (yea, it’s weird, I have no clue what was going on internally here). I found a few quick and dirty solutions to this problem by playing around with optimization settings, but eventually hit a brick wall, where no amount of fidgeting with optimization parameters resulted in compilation/linking going forward. Installing SP1 solved the issue and may have solved the earlier issues as well without me having to play with optimization settings.

So, onwards we go,

• I found that after opening the WebKit solution, none of the projects were loaded. This is because the project files are looking for *.vsprops files in WebKit\WebKitLibraries\tools\vsprops, but the vsprops files are actually in WebKit\WebKitLibraries\win\tools\vsprops. The simplest solution is just copy over what’s in the /win directory into the parent directory (WebKit\WebKitLibraries). Looking at WebKit\WebKitLibraries now, I copied over the win/tools folder and the files in /win. Alternatively, you can edit the project files (they’re XML files, you can open them up in a text editor).
  
• Set the 2 environment variables necessary for compiling within VC++,
  
• WEBKITLIBRARIESDIR = cygwin\home\<user>\WebKit\WebKitLibraries
• WEBKITOUTPUTDIR = cygwin\home\<user>\WebKit\WebKitBuild

• Get the Platform SDK, specifically the Windows Server 2003 Ed. of the Platform SDK. I did not have luck getting it to work with an older or newer version of the SDK. I didn’t install the R2 update; I’m not sure what effect it would have.
• Update VC++ directories:
• Executables >> add cygwin/bin, windows/system32, Platform SDK/bin
• Includes >> Platform SDK/include
• Library Files >> Platform SDK/lib

• Update VC++ directories for the WebKit Support Library:
• Includes >> WebKit\WebKitSupportLibrary\WebKitSupportLibrary\win\include
• Library Files >> WebKit\WebKitSupportLibrary\WebKitSupportLibrary\win\lib

• Update VC++ directories for JavaScriptCore/icu:
• Includes >> WebKit\JavaScriptCore\icu

• Update VC++ directories for WebCoreSQLite3:
• Includes >> WebKit\WebKitLibraries\WebCoreSQLite3

• Update VC++ directories for JavaScriptCore:
• Includes >> WebKit\JavaScriptCore

• I had issues with the ARRAYSIZE macro not being defined, so in WebCore/config.h, add the following:
  
  #ifndef ARRAYSIZE
#define ARRAYSIZE(A) (sizeof(A)/sizeof((A)[0]))
#endif

  right before the line,
  
  #endif /* PLATFORM(WIN_OS) */


• Get rid of cygwin’s link.exe in cygwin/bin (rename it or delete it). This causes a conflict with the real linker (VC++’s link.exe). It was likely caused by the order in which VC++ executable directories were set, so if you need it, you might be able to keep it.
  
• For the QtMovieWin project, edit all source files (there’s only 2) so that windows.h is included first (this is due to macro above, which will now cause a macro redefinition by the preprocessor).
• For QtMovieWin, also rearrange the order of include, so that #include <wtf/Vector.h> is included before config.h and windows.h to prevent some min/max macro nonsense.
• For QtMovieWin, take off prompt error reporting for linking (ERRORREPORT:PROMPT) project (see Linker >> Advanced page in project setting).
• Make a new config file by copying WebCore/config.h and making WebCore/config_qt.h. Remove the ARRAYSIZE macro defintions from config_qt.h. Update all files in QtMovieWin project so that config_qt.h is included instead of config.h.
• Install the QuickTime SDK.
• Update VC++ directories:
• Includes >> QuickTime 7.3 SDK\CIncludes
• Library Files >> QuickTime 7.3 SDK\Libraries
  

• For QtMovieWin, make sure you linker inputs are set correctly for QuickTime libraries and VC++ can find them.
• For QtMovieWin, add “CoreFoundation.lib” to linker inputs.
• (This may have been an issue caused by not having SP1, you might not have to do this, try compiling first) Turn off whole program optimization for all projects.
• (This may have been an issue caused by not having SP1, you might not have to do this, try compiling first) Turn off treat warnings as errors for JavaScriptCore, WebKit, WebKitGUID, WebCore, and WTF projects.

That should do it.

Some general advice, work from within VC++ and compile as you make changes; make it a touch-and-go operation. In this way you see errors as they occur and can more easily spot and fix issues. Don’t simply follow what I’ve written above as tutorial thinking it’s a sure-fire solution for compilation, things may very likely change with different iterations of the code.