Register assignment in HLSL

kayru — Sun, 27 Jun 2010 01:08:32 +0000

When you are manually assigning shader constants to registers (using a ‘register’ keyword), those registers are also taken out of the automatic assignment pool.
This means that constants that don’t have explicit registers will never overlap with ones that do even if latter are not used in the shader.
And so code like this:
float4 c0 : register(c0); float4 c1 : register(c2); float4 c2; float4 main():POSITION { return c2; }

Will compile into this:
vs_2_0 mov oPos, c1

This is a pretty small thing, but still quite convenient and useful to know.

C++ gotchas

kayru — Sat, 02 May 2009 18:47:52 +0000

Today I’m going to write about virtual function hiding.

Consider the following code:

#include <stdio.h>

class Foo
{
public:
    virtual void fun(int)
    {
        printf("A");
    }
    virtual void fun(bool)
    {
        printf("B");
        fun(int());
    }
};

class Bar : public Foo
{
public:
    virtual void fun(int)
    {
        printf("C");
    }
};

int main()
{    

    Bar b;
    b.fun(bool());    

    return 0;
}

What will be written to the console?

You will see “C”.

Overloading virtual function fun() in class Bar hides all other versions of functions with that name. Combined with implicit type casting, this may lead to undesirable behaviour.

This is the same problem as you get with multiple inheritance. To fix it, we need to explicitly specify what we want to inherit by adding the following statement to Bar class declaration:
class Bar
{
…
public:
using Foo::fun;
…
}

With this statement, output becomes “BC”.

Neither VC++ 8 nor GCC 4 will warn about this. Therefore, regular linting is a must to flush-out bugs like this.

Yuriy O'Donnell's blog » Coding

Register assignment in HLSL

C++ gotchas