No, I am not kidding, after a week of optimizing I just reached almost 3 Mio FPS with our engine. I had to disable Clearing/Present and Input, but this is my log output (thanks to PerformanceCounters this is also pretty accurate):

FPS: 2703785

With Input enabled I can easily go above 200000 FPS, most time of each frame is in whatever platform Input GetState method does:

FPS: 202099

With Present (clear is not needed in my test as I draw a fullscreen quad) it goes down to ~13000 FPS, which is not shabby, but almost all time is lost in Present of XNA 4.0 CTP, which hasn't been optimized a lot yet by the XNA Team (the main module I use currently, but we support many different graphic frameworks as well, XNA is just the best for Windows IMO). Might sound crazy, but for performance checking I disable Present because then I immediately see whats slow in the render code.

FPS: 12680

Other platforms are much worse, but it is always waiting for the graphic card or some external library, so I would say our engine is quite fast as of now. I obviously did not have much enabled in my test (just a test screen drawing a big quad, and Time, Input, Graphic, SceneManager, MaterialManager and Profiling modules enabled), but even doing more stuff does not hurt FPS wise. A more complex 2D screen could still achieve 10000 FPS. Next up is 3D optimization, which is much harder obviously (we are still not fast enough, especially on other platforms).

//  PassTouchesScrollView.m
//  Simple helper class for UIScrollViews that need to pass touchesBegan to the
//  UIViewController above it (see all the Controller classes here).
#import "PassTouchesScrollView.h"

@implementation PassTouchesScrollView

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
{
	UIView *result = nil;
	for (UIView *child in self.subviews)
		if ([child pointInside:point withEvent:event])
			if ((result = [child hitTest:point withEvent:event]) != nil)
				break;

	return result;
}

- (void)dealloc
{
    [super dealloc];
}

@end

-(void) touchesEnded: (NSSet *) touches withEvent: (UIEvent *) event
{
	// Pass to parent
	[super touchesEnded:touches withEvent:event];
	[self.nextResponder touchesEnded:touches withEvent:event];
}

#preload img
{
height: 0; width: 0; border-width: 0;
position: absolute;
bottom: 0;
left: 0;
z-index: -30;
}

etc. for each image ..

[HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\9.0\Text Editor]
"Guides"="RGB(64,64,192) 79"

If you ever have wondered why you need all these Object class method in your class intellisense list, this is the right article for you. I recently wrote an Assert class for our own unit testing system (as reported yesterday we were pretty unhappy with TestDriven.net+xunit in our engine). Even though I have only written 10 methods in the Assert class, which I think are the most essential ones for unit testing, whenever I write Assert. Intellisense pops up with 15 Items instead of 10. In my case (statically accessing Assert) the following 5 Items were displayed without my consens:

• The Contains method appears 2 times because one is using strings, the other overload is using generics
• object.Equals appears because every class is derived from object!
• Same for object.ReferenceEquals
• The sub class Tests appears to, but I only need it for unit testing (but it needs to be public for xunit)
• And finally there is a delegate ThrowsDelegate, which is needed for the Throws method.

Additionally if you access a class via an instance (not statically) you will get the following object methods displayed in your intellisense too:

• Equals (there is one static method with 2 arguments and a non static one with 1 argument)
• GetType
• GetHashCode
• And finally ToString

I cannot remember the last time I really needed those object methods in any classes intellisense. Luckily there is an easy solution to fix this, but you need to be aware that it does not work in every situation. But as you can see I managed to reduce my Assert class intellisense list down to the 10 items I really wanted:

Basically you just add the following attribute to any method, sub class or property that you do not want to appear in the intellisense list:

[EditorBrowsable(EditorBrowsableState.Never)]

This works fine and dandy with your own methods (like in my example the ThrowsDelegate and the Tests sub class, but what about those nasty object methods? Well, static methods you can just re-implement with the new keyword (overwriting the original methods) and just specify the EditorBrowsable attribute there:

#region Hide object.Equals and object.ReferenceEquals
/// 

/// Equals
/// 
[EditorBrowsable(EditorBrowsableState.Never)]
public new static bool Equals(object objA, object objB)
{
	return object.Equals(objA, objB);
} // Equals(objA, objB)

/// 

/// Reference equals
/// 
[EditorBrowsable(EditorBrowsableState.Never)]
public new static bool ReferenceEquals(object objA, object objB)
{
	return object.ReferenceEquals(objA, objB);
} // ReferenceEquals(objA, objB)
#endregion

For the non-static methods we can even use a simpler trick by deriving your class from the following IHideObjectMembers interface, which already adds the required attributes to the 4 annoying object methods.

/// 

/// Helper interface used to hide the base  members from
/// your classes to make intellisense much cleaner. Note: This ONLY works
/// from other assemblies AND you MUST NOT have the project using this
/// interface in your solution (else VS will still show them).
/// 
[EditorBrowsable(EditorBrowsableState.Never)]
public interface IHideObjectMembers
{
	[EditorBrowsable(EditorBrowsableState.Never)]
	Type GetType();

	[EditorBrowsable(EditorBrowsableState.Never)]
	int GetHashCode();

	[EditorBrowsable(EditorBrowsableState.Never)]
	string ToString();

	[EditorBrowsable(EditorBrowsableState.Never)]
	bool Equals(object obj);
} // interface IHideObjectMembers

One final thing I had to do to get rid of my two Contains methods was to rewrite the string one to a generic one, so it appears together with the other generic one (using lists) in the Intellisense list, but that was no biggy.


When you try this out you might wonder why the hell it is not working for you and sadly the answer is: Yes, it does not work all of the time. As already mentioned in the IHideObjectMembers implementation the hiding only works if you DO NOT HAVE the assembly from the class you are intellisensing in your solution. You need to reference it as an dll (a local file or from the GAC). Even then you might want to create a new solution for testing this out. The strange thing is that after a while VS seems to learn and will use your reduced intellisense even if you have the project in the solution, but I have no idea why this sometimes works (when writing this blog entry it almost always worked inside my Assert assembly even). Anyway, it is still a very useful trick IMO.

If you have 50+ projects in a single solution it can be annoying that you cannot collapse them all with a single click or keystroke. Expanding everything can be simply done with Numpad * at any node in the solution explorer. Having so many projects in a solution and compiling them all everytime you F5 something is not such a good idea because compile time goes through the roof (even though each single project is compiled really quickly, usually in much less than a second). Please note that our projects are mostly very simple and having so many projects is by design because they only implement certain features and can be easily replaced (or there are several modules for the same feature, just doing differently or for different platforms). We should blog about that too, I think it is a pretty good idea and makes refactoring and multiplatform development much easier than big projects and lots of ugly defines (we have almost no defines right now and are pretty happy with it).

To solve this we have a little helper tool that recursively selects the projects you need for any given project you want to work on, then you end up with 3-4 projects instead of 50+ (we have like 10-20 new projects every month, so this will probably increase for a while). An alternate solution is to fiddle with the build settings in the Configuration Manager to just compile some projects, but not the rest. But this is very error prone and can cause many headaches because you forgot to compile some project you changed some little thing and then your code will still execute the old .dll with the old code missing your newly implemented functionality.

But the problem with so many projects, and usually in any kind of Visual Studio solution, is that you cannot easily collapse all projects at once. Instead you have to collapse them one by one, which can be fun with 5 projects, but it is certainly not funny with 50+ projects anymore and you practically have to do it every day to keep the solution explorer short and tidy. Luckily some clever people solved this problem many years ago with macros or extensions and I like the simple macro version. There is a great tutorial with all required steps available, which you can use to set it up for your Visual Studio. We use a slightly modified macro that works better with our sub folders that have projects too:

Imports System
Imports EnvDTE
Imports System.Diagnostics

Public Module Collapse
    Sub CollapseAll()
        ' Get the the Solution Explorer tree
        Dim UIHSolutionExplorer As UIHierarchy
        UIHSolutionExplorer = DTE.Windows.Item(Constants.vsext_wk_SProjectWindow).Object()
        ' Check if there is any open solution
        If (UIHSolutionExplorer.UIHierarchyItems.Count = 0) Then
            ' MsgBox("Nothing to collapse. You must have an open solution.")
            Return
        End If
        ' Get the top node (the name of the solution)
        Dim UIHSolutionRootNode As UIHierarchyItem
        UIHSolutionRootNode = UIHSolutionExplorer.UIHierarchyItems.Item(1)
        UIHSolutionRootNode.DTE.SuppressUI = True
        ' Collapse each project node
        Dim UIHItem As UIHierarchyItem
        For Each UIHItem In UIHSolutionRootNode.UIHierarchyItems
            'UIHItem.UIHierarchyItems.Expanded = False
            If UIHItem.UIHierarchyItems.Expanded Then
                Collapse(UIHItem)
            End If
        Next
        ' Select the solution node, or else when you click 
        ' on the solution window
        ' scrollbar, it will synchronize the open document 
        ' with the tree and pop
        ' out the corresponding node which is probably not what you want.
        UIHSolutionRootNode.Select(vsUISelectionType.vsUISelectionTypeSelect)
        UIHSolutionRootNode.DTE.SuppressUI = False
    End Sub

    Private Sub Collapse(ByVal item As UIHierarchyItem)
        ' Recursively collapse
        For Each eitem As UIHierarchyItem In item.UIHierarchyItems
            If eitem.UIHierarchyItems.Expanded AndAlso eitem.UIHierarchyItems.Count > 0 Then
                Collapse(eitem)
            End If
        Next

        ' First try to collapse
        item.UIHierarchyItems.Expanded = False

        ' Check if it failed, if yes, then do it manually
        If item.UIHierarchyItems.Expanded = True Then
            item.Select(vsUISelectionType.vsUISelectionTypeSelect)
            DTE.ToolWindows.SolutionExplorer.DoDefaultAction()
        End If
    End Sub
End Module

It is almost old news that Visual Studio 2010 was delayed from March 2010 to some unanounced date a few weeks later (plus the beta period was extended). However, many people I know are not doing anything with VS2010 Beta2 yet and only want to switch to VS2010 when it is really stable plus many addins are available. As reported 3 months ago (when VS2010 came out in Oct2009) we were pretty happy with VS2010 Beta 2, most things worked just fine, but we could not use CodeRush. Without CodeRush most team members were far less productive, so we switched back to VS2008 after a few days. Since DevExpress has not released a VS2010 compatible version of CodeRush yet (see their 2010 roadmap, CodeRush 2010 will be released when VS2010 is final), we are still using VS2008.

However, I am currently writing an addin for our engine and I really want to replace xunit/TestDriven.net because it just does not work for us anymore. We have a lot of problems with other platforms, with static unit tests, graphical tests, logging, etc. Instead of living or circumventing all these problems (this is what we have done in the last few months) we really want to be more productive and have things just work, which is especially important for unit tests IMO. I like writing VS2010 addins much more than to fiddle around with the VS2008 SDK and since we will switch soon anyway, I will write this plugin in VS2010. In the meantime we will try to use some simple VS macros to accomplish basic testing jobs. I will blog more about this in a bit.

In case you are afraid of being laid off, there are some tips how to make yourself irreplaceable by writing really unmaintainable code. It is a really funny read and every sane person will suggest the exact opposite. My only question is how can you really do any work when your own code is so unmaintainable ..

http://phpadvent.org/2009/unmaintainable-php-by-stoyan-stefanov

Have a nice christmas and a happy new year in case no one blogs here anymore. But we will probably take a few photos from our christmas party today and post something fun for christmas ..