On a related note, folks at Stack overflow however have wondered how you can achieve glow/halo effects on text.

Apparently it’s easy to do in Flash – you just use the glow filter. Silverlight unfortunately doesn’t have one out of the box. So, I decided to try put in one. Presenting:

Check out the full sample and get the source code.

A few notes:

• this is more of a proof-of-concept effect. It might have some bugs as is. It also needs a few features on top.
• to compile the shader with DirectX’s effect compiler use the following command :

  fxc /T ps_2_0 /Vd /Fo GlowEffect.pso GlowEffect.ps

• the presented effect is for outer glow only – it doesn’t implement knockout or inner glow. Those won’t be hard to implement on top of this code, though. Maybe a bit of conditional compilation.
• the glow radius is fixed at 4 pixels. This is a limitation of the approach used – PS 2.0 doesn’t support loops. The compiler demands that all syntactic loops be unrolled at compile time. The shader has a constant for the glow radius – increasing it will increase the glow radius after recompiling the shader. The problem is that the shader compiler takes more and more time as the radius increases – currently it takes 1-2s to compile. I have actually no idea how e.g. the stock BlurEffect was implemented to support an arbitrary blur radius. The shader can be enhanced to take an arbitrary radius though, that still must be smaller than the ‘max radius’ in the shader. Note that if you change the glow radius, you must also increase the Padding used in the GlowEffect class.
• “approximately 193 instruction slots used (49 texture, 144 arithmetic)” which is well over the limit of PS 2.0 (32 tex, 64 arith) – case in point that silverlight isn’t bound by standard limitations.
• the sample is built against Silverlight 4.0, although there is no reason for the code to not work on older versions.

In today’s installment a tester called that there was a problem connecting to the server-side. Investigation showed that the problem was that the plugin thought there was no cross-domain policy in place. Incidentally the tester opened the client application without omitting the www. part, which lead to the need to use cross-domain access policy. Moving along, the problem only appeared on IE – Chrome and Firefox work fine.

The problem turned out to be an old Silverlight.js that was generated by the SL3 wizard for ASP.NET SL test pages.

I downloaded the latest Silverlight.js from MSDN

…and problem solved.

The main point of confusion about this is that people think that there is some inherent limitation in PS2.0 to support more instructions. There actually isn’t – the shader model is just a specification of the minimum of supported features in *hardware*. If a video card supports PS2.0, then it guarantees that it can meet at least the requirements for PS2.0. In fact, modern hardware will probably run ps_2_0-targeted shaders with more than 64 instruction even though they are technically non-standard (it’s actually just a driver issue). The same shaders will almost certainly be incompatible with video cards that support only up to ps_2_0, though.

Now, Silverlight shaders are (to some extent – unfortunately) run on the CPU. They’re, in a sense, interpreted. As such, there really are no hardware-specific limitations that would prohibit Silverlight to render non-standard (in the sense of instruction count) shaders – in fact, it just works! There is nothing to stop you to compile a million instruction shader! (save for DirectX SDK’s effect compiler’s bogus performance on slightly larger shaders)

Well, enough exposition – I guess by now you just want to know how to compile long shaders for Silverlight effects. Normally you compile shaders with the following command or a variation thereof:
> fxc /T ps_2_0 /Fo effect.pso effect.ps

To enable long shaders, just append the /Vd option to the command line. It just disables shader model compatibility validation and lets you deal eventually with potential incompatibilities.

Now that you’ve handled the issue of instruction count, prepare to weep because of the code generator’s imperfections… good luck.

    /// <summary>
    /// Weak delegates are useful where you don't want the lifetime of a delegate target
    /// to be bound to the delegate's lifetime.
    ///
    /// The WeakDelegateFactory is used for the the same purpose as WeakEventHandler, but
    /// can work for any delegate type. Is uses Reflection.Emit to create an exact replica
    /// of the WeakEventHandler class, but for the specific delegate type.
    /// </summary>
    public static class WeakDelegateFactory
    {
        private static AssemblyBuilder theDelegatesAsm;
        private static ModuleBuilder theModuleBuilder;

        public static TDelegate Create<TDelegate>(TDelegate targetDelegate, Action<TDelegate> unregisterDelegate) where TDelegate : class
        {
            EnsureBuildersCreated();

            var type = targetDelegate.GetType();

            if (type.GetMethod("Invoke").ReturnType != typeof(void))
                throw new ArgumentException("Weak delegates can only be created for delegates with void return type.", "targetDelegate");

            // create the class builder that will give birth to this weak delegate class
            var className = "WeakDelg->" + GetPrettyName(type);
            var classType = theModuleBuilder.GetType(className)
                            ?? CreateWeakDelegateClass(targetDelegate, type, className);

            var ctor = classType.GetConstructors()[0];
            var weakDelg = ctor.Invoke(new object[] { targetDelegate, unregisterDelegate });
            return (TDelegate) (object) Delegate.CreateDelegate(type, weakDelg, classType.GetMethod("Invoke"));
        }

        private static Type CreateWeakDelegateClass<TDelegate>(TDelegate targetDelegate, Type type, string className) where TDelegate : class
        {
            var classBuilder = theModuleBuilder.DefineType(className, TypeAttributes.Class | TypeAttributes.Public);

            // create the class fields for the unbound delegate, the weak reference to the delegate's target and an unregister callback
            var weakRefFld = classBuilder.DefineField("myWeakRef", typeof(WeakReference), FieldAttributes.Private);

            MethodBuilder unboundDelgInvoke;
            var unboundDelgType = CreateUnboundDelegateType(classBuilder, targetDelegate, out unboundDelgInvoke);
            var unboundDelgFld = classBuilder.DefineField("myUnboundDelg", unboundDelgType, FieldAttributes.Private);

            var unregisterDelgFld = classBuilder.DefineField("myUnregisterDelg", typeof(Action<TDelegate>), FieldAttributes.Private);

            // create constructor
            DefineConstructor<TDelegate>(type, classBuilder, unboundDelgType, weakRefFld, unboundDelgFld, unregisterDelgFld);

            // create the method that implements the weak delegate calling
            DefineInvokeMethod(targetDelegate, classBuilder, weakRefFld, unboundDelgFld, unregisterDelgFld, unboundDelgInvoke);

            unboundDelgType.CreateType();
            return classBuilder.CreateType();
        }

        private static void DefineConstructor<TDelegate>(Type delegateType, TypeBuilder classBuilder, TypeBuilder unboundDelgType, FieldBuilder weakRefFld, FieldBuilder unboundDelgFld, FieldBuilder unregisterDelgFld)
        {
            var target = delegateType.GetProperty("Target");
            // create the constructor; it initializes the unbound delegate and the weak reference
            var constructor = classBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis,
                                                             new[] { delegateType, typeof(Action<TDelegate>) });
            var ctorIl = constructor.GetILGenerator();

            // call object.ctor()
            ctorIl.Emit(OpCodes.Ldarg_0);
            ctorIl.Emit(OpCodes.Call, typeof(object).GetConstructor(new Type[] { }));

            // store a WeakReference to the delegate's target into a field
            ctorIl.Emit(OpCodes.Ldarg_0);
            ctorIl.Emit(OpCodes.Ldarg_1);
            ctorIl.Emit(OpCodes.Callvirt, target.GetGetMethod());
            ctorIl.Emit(OpCodes.Newobj, typeof(WeakReference).GetConstructor(new[] { typeof(object) }));
            ctorIl.Emit(OpCodes.Stfld, weakRefFld);

            // create an unbound delegate type from the given delegate's method
            ctorIl.Emit(OpCodes.Ldarg_0); // for stfld
            ctorIl.Emit(OpCodes.Ldtoken, unboundDelgType);
            ctorIl.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle", new[] { typeof(RuntimeTypeHandle) })); // first parameter; load the unbound delegate's type
            ctorIl.Emit(OpCodes.Ldnull); // second parameter; no instance given, i.e. treat it as a static method
            ctorIl.Emit(OpCodes.Ldarg_1); // third parameter to CreateDelegate
            ctorIl.Emit(OpCodes.Callvirt, typeof(Delegate).GetProperty("Method").GetGetMethod());
            ctorIl.Emit(OpCodes.Call, typeof(Delegate).GetMethod("CreateDelegate", new[] { typeof(Type), typeof(object), typeof(MethodInfo) }));
            ctorIl.Emit(OpCodes.Castclass, unboundDelgType);
            ctorIl.Emit(OpCodes.Stfld, unboundDelgFld);

            // store the unregister callback
            ctorIl.Emit(OpCodes.Ldarg_0);
            ctorIl.Emit(OpCodes.Ldarg_2);
            ctorIl.Emit(OpCodes.Stfld, unregisterDelgFld);

            ctorIl.Emit(OpCodes.Ret);
        }

        private static void DefineInvokeMethod<TDelegate>(TDelegate targetDelegate, TypeBuilder classBuilder, FieldBuilder weakRefFld, FieldBuilder unboundDelgFld, FieldBuilder unregisterDelgFld, MethodBuilder unboundDelgInvoke) where TDelegate : class
        {
            var targetType = ((Delegate) (object) targetDelegate).Target.GetType();
            var unregisterDelgType = typeof(Action<TDelegate>);
            var delegateType = targetDelegate.GetType();
            var delegateSignature = delegateType.GetMethod("Invoke");
            var delgParamTypes = GetParameterTypes(delegateSignature);
            var invoker = classBuilder.DefineMethod("Invoke", MethodAttributes.Public, delegateSignature.ReturnType, delgParamTypes.ToArray());
            var invokerIl = invoker.GetILGenerator();

            var targetLocal = invokerIl.DeclareLocal(targetType);

            var endLabel = invokerIl.DefineLabel();
            var targetIsNullLabel = invokerIl.DefineLabel();

            // get Target from weak reference
            invokerIl.Emit(OpCodes.Ldarg_0);
            invokerIl.Emit(OpCodes.Ldfld, weakRefFld);
            invokerIl.Emit(OpCodes.Callvirt, typeof(WeakReference).GetProperty("Target").GetGetMethod());
            invokerIl.Emit(OpCodes.Isinst, targetType);
            invokerIl.Emit(OpCodes.Castclass, targetType);
            invokerIl.Emit(OpCodes.Stloc, targetLocal);
            invokerIl.Emit(OpCodes.Ldloc, targetLocal);
            invokerIl.Emit(OpCodes.Brfalse_S, targetIsNullLabel);

            // the target is not null - call the unbound delegate
            invokerIl.Emit(OpCodes.Ldarg_0);
            invokerIl.Emit(OpCodes.Ldfld, unboundDelgFld);
            invokerIl.Emit(OpCodes.Ldloc, targetLocal);
            invokerIl.Emit(OpCodes.Ldarg_1);
            invokerIl.Emit(OpCodes.Ldarg_2);
            invokerIl.Emit(OpCodes.Callvirt, unboundDelgInvoke);
            invokerIl.Emit(OpCodes.Ret);

            invokerIl.MarkLabel(targetIsNullLabel);
            // target was null, call unregister
            invokerIl.Emit(OpCodes.Ldarg_0);
            invokerIl.Emit(OpCodes.Ldfld, unregisterDelgFld);
            invokerIl.Emit(OpCodes.Brfalse_S, endLabel); // check if unregister is null
            invokerIl.Emit(OpCodes.Ldarg_0);
            invokerIl.Emit(OpCodes.Ldfld, unregisterDelgFld);
            invokerIl.Emit(OpCodes.Ldarg_0);
            invokerIl.Emit(OpCodes.Ldftn, invoker);
            invokerIl.Emit(OpCodes.Newobj, delegateType.GetConstructor(new[] { typeof(object), typeof(IntPtr) })); // create delegate from invoke
            invokerIl.Emit(OpCodes.Callvirt, unregisterDelgType.GetMethod("Invoke")); // call unregister
            invokerIl.Emit(OpCodes.Ldarg_0);
            invokerIl.Emit(OpCodes.Ldnull);
            invokerIl.Emit(OpCodes.Stfld, unregisterDelgFld); // nullify unregister
            invokerIl.MarkLabel(endLabel);

            invokerIl.Emit(OpCodes.Ret);
        }

        private static void EnsureBuildersCreated()
        {
            if (theDelegatesAsm == null)
            {
                theDelegatesAsm = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("WeakDelegates"), AssemblyBuilderAccess.Run);
                theModuleBuilder = theDelegatesAsm.DefineDynamicModule("WeakDelegates");
            }
        }

        /// <summary>
        /// Creates an unbound delegate type from the type of a normal delegate
        /// </summary>
        private static TypeBuilder CreateUnboundDelegateType(TypeBuilder parentClass, object boundDelegate, out MethodBuilder outInvokeMethod)
        {
            var invokeMethod = boundDelegate.GetType().GetMethod("Invoke");
            var targetType = ((Delegate) boundDelegate).Target.GetType();
            return CreateDelegateType(parentClass, invokeMethod.ReturnType, new[] { targetType }.Concat(GetParameterTypes(invokeMethod)).ToArray(), out outInvokeMethod);
        }

        private static IEnumerable<Type> GetParameterTypes(MethodInfo mi)
        {
            return from p in mi.GetParameters() select p.ParameterType;
        }

        /// <summary>
        /// Basically does what the compiler does when it has to compile a delegate statement.
        /// Creates the delegate as a nested type.
        /// </summary>
        /// <returns>A class derived from System.MulticastDelegate that can be called with the given parameters</returns>
        private static TypeBuilder CreateDelegateType(TypeBuilder parentClass, Type returnType, Type[] parameters, out MethodBuilder outInvokeMethod)
        {
            // from Joel Pobar's CLR weblog
            // Creating delegate types via Reflection.Emit
            // http://blogs.msdn.com/joelpob/archive/2004/02/15/73239.aspx

            var delgTypeBuilder = parentClass.DefineNestedType("UnboundDelegate", TypeAttributes.Class | TypeAttributes.NestedPublic | TypeAttributes.Sealed | TypeAttributes.AnsiClass | TypeAttributes.AutoClass, typeof(MulticastDelegate));
            var constructorBuilder = delgTypeBuilder.DefineConstructor(MethodAttributes.RTSpecialName | MethodAttributes.HideBySig | MethodAttributes.Public, CallingConventions.Standard, new[] { typeof(object), typeof(IntPtr) });
            constructorBuilder.SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed);

            outInvokeMethod = delgTypeBuilder.DefineMethod("Invoke", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual, returnType, parameters);
            outInvokeMethod.SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed);

            return delgTypeBuilder;
        }

        private static string GetPrettyName(Type t)
        {
            if (t.IsGenericType)
            {
                return t.Namespace + '.' + t.Name + '(' + String.Join(";", (from p in t.GetGenericArguments() select p.Name).ToArray()) + ')';
            }
            else
            {
                return t.FullName;
            }
        }
    }

Note that we use Reflection.Emit to do the onerous code generation – we could’ve used CSharpCodeProvider to the same effect, so why didn’t we? Well, CSharpCodeProvider isn’t available in Silverlight, so there. This code works in Silverlight as it does in .NET. The only inherent limitation in Silverlight (as with the code in Campbell’s article) is that the bound method must be public enough – otherwise trying to create an unbound delegate from the delegate target throws a SecurityException.

The code probably works – it’s more of a proof of concept than anything else. I’ve used it in production code, so there aren’t any train-wrecking problems in it. There is probably more stuff needed to make it work in all cases, however.

This is how you use it:

        public event Action<int> SomeEvent;

        private void Register()
        {
            SomeEvent += WeakDelegateFactory.Create(new Action<int>(Sink), e => SomeEvent -= e);
        }

        private void Sink(int foo)
        {}

It would have been great if methods were implicitly usable as delegates. You could then write (with an appropriate extension method) SomeEvent += Sink.ToWeak(e=>SomeEvent-=e);

This is our proxy property – it uses a property change callback to translate position changes into Canvas.Left and Canvas.Top property changes.

    public class CanvasServices
    {
        public static readonly DependencyProperty CanvasPositionProperty =
            DependencyProperty.RegisterAttached("CanvasPosition", typeof (Point), typeof (CanvasServices),
                                                new PropertyMetadata(new Point(), CanvasPositionChanged));

        private static void CanvasPositionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var position = (Point) e.NewValue;
            d.SetValue(Canvas.LeftProperty, position.X);
            d.SetValue(Canvas.TopProperty, position.Y);
        }

        public static void SetCanvasPosition(DependencyObject d, Point position)
        {
            d.SetValue(CanvasPositionProperty, position);
        }

        public static Point GetCanvasPosition(DependencyObject d)
        {
            return (Point) d.GetValue(CanvasPositionProperty);
        }
    }

    <Canvas x:Name="LayoutRoot" Background="White">
        <Ellipse Height="44" HorizontalAlignment="Left" Stroke="Black"
                 StrokeThickness="1" VerticalAlignment="Top" Width="58"
                 x:Name="myElli"/>
        <Canvas.Resources>
            <Storyboard x:Name="myStory">
                <PointAnimation From="20,20" To="200,200" Duration="0:0:3"
                    Storyboard.TargetName="myElli" x:Name="myAnim"/>
            </Storyboard>
        </Canvas.Resources>
    </Canvas>

Storyboard.SetTargetProperty(myAnim, new PropertyPath(CanvasServices.CanvasPositionProperty));
myStory.Begin();

That’s it. As you can see, custom attached properties can be used to change the way existing SL properties are aggregated in objects and used with animations.

If EnableGPUAcceleration is true AND EnableFrameRateCounter is true, an additional frame counter displays in the upper-left corner as an overlay within the Silverlight content area. The format of this frame rate counter is as follows:

frameRate videoMemoryUsed GPUEnabledSurfaces intermediateSurfaces

videoMemoryUsed is in KB. intermediateSurfaces refers to surfaces implicitly created to represent the software-rendered parts of the application on the GPU.