i used particles, cycles, glowing materials and the compositor.

how do you like it?

[
    {
        Key: "key1",
        Value: "value1"
    },
    {
        Key: "key2",
        Value: "value2"
    }
]

But you want a correct JSON dictionary format:

{
    "key1": "value1",
    "key2": "value2"
}

What happens here? Serializing a dictionary is the same as you would serialize a list of objects.

This means that this:

Dictionary<string, object> dic = new Dictionary<string, object>();
dic.Add("key1", "value1");
dic.Add("key2", "value2");

… is the same as this:

public class KeyValue
{
    public string Key { get; set; }
    public string Value { get; set; }
    [...]
}
 
public class Dictionary
{
    public List<KeyValue> Values { get; set; }
    [...]
}

The serializer takes every item from Dictionary.Values and writes the KeyValue object into the output.
This behaviour is not bad or wrong but it is unsuitable for a JSON dictionary output.

What we want is a “Key: Value” output like this:

{
    "key1": "value1",
    "key2": "value2"
}

What you need to do is implementing a Dictionary-like object that inherits from ISerializable.

Here is the implementation of it:

/// <summary>
/// This key value collection is used to serialize a dictionary into json format and back.
/// </summary>
[Serializable]
public sealed class KeyValueCollection : ISerializable
{
    /// <summary>
    /// Holds the internal dictionary.
    /// </summary>
    private readonly Dictionary<string, string> _dictionary;
 
    /// <summary>
    /// Initializes a new instance of the <see cref="KeyValueCollection"/> class.
    /// </summary>
    public KeyValueCollection()
    {
        this._dictionary = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
    }
 
    /// <summary>
    /// Initializes a new instance of the <see cref="KeyValueCollection"/> class.
    /// </summary>
    /// <param name="dictionary">The dictionary.</param>
    public KeyValueCollection(Dictionary<string, string> dictionary)
    {
        this._dictionary = new Dictionary<string, string>(dictionary, StringComparer.InvariantCultureIgnoreCase);
    }
 
    /// <summary>
    /// Initializes a new instance of the <see cref="KeyValueCollection"/> class.
    /// </summary>
    /// <param name="info">The serialization info.</param>
    /// <param name="context">The streaming context.</param>
    protected KeyValueCollection(SerializationInfo info, StreamingContext context) : this()
    {
        foreach (var entry in info)
        {
            this._dictionary.Add(entry.Name, entry.Value.ToString());
        }
    }
 
    /// <summary>
    /// Gets or sets the <see cref="System.String"/> with the specified key.
    /// </summary>
    public string this[string key]
    {
        get
        {
            return !this._dictionary.ContainsKey(key) ? null : this._dictionary[key];
        }
        set
        {
            this._dictionary[key] = value;
        }
    }
 
    /// <summary>
    /// Gets the internal dictionary as copy.
    /// </summary>
    /// <returns>The internal dictionary as copy.</returns>
    public Dictionary<string, string> GetDictionary()
    {
        return new Dictionary<string, string>(this._dictionary);
    }
 
    /// <summary>
    /// Populates a SerializationInfo with the data needed to serialize the target object.
    /// </summary>
    /// <param name="info">The SerializationInfo to populate with data.</param>
    /// <param name="context">The destination (see StreamingContext) for this serialization.</param>
    /// <exception cref="T:System.Security.SecurityException">The caller does not have the required permission.</exception>
    void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
    {
        foreach (string key in this._dictionary.Keys)
        {
            info.AddValue(key, this._dictionary[key], typeof(string));
        }
    }
 
    /// <summary>
    /// Adds the item with the specified key.
    /// </summary>
    /// <param name="key">The key.</param>
    /// <param name="value">The value.</param>
    public void Add(string key, string value)
    {
        this[key] = value;
    }
}

Note:

As you might have seen that i use Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
The StringComparer.InvariantCultureIgnoreCase argument helps me to treat all the keys case insensitive.

If you want to work on the directory directly (query) use the method GetDictionary().

Sources:

First http://blog.masonchu.com/2012/03/wcf-webapi-dictionary-json.html
Second http://stackoverflow.com

But this is especially needed is you want to use “-setParam” for a tokenized (transformed) web.config file and wont / can’t change the SetParameter.xml!
(The names of the parameters for -setParam can be found in the SetParameter.xml file in the same directory as the Package.zip. They are also act as default values if not set in the command line call. )

So I wrote this quick tutorial how to get command line call for MSDeploy.
(Please consider that the paths you will later use are absolute / relative to the working directory.)

Step 1: Get the publish ready with MSBuild

Before we will get some further results please get your deployment call working.

msbuild.exe
SomeWebProject.csproj
/P:Configuration=Release
/P:DeployOnBuild=True
/P:DeployTarget=MSDeployPublish
/P:MsDeployServiceUrl=https://TargetServer/MsDeploy.axd
/P:AllowUntrustedCertificate=True
/P:MSDeployPublishMethod=WMSvc
/P:CreatePackageOnPublish=True
/P:UserName=Username
/P:Password=Password
/P:DeployIisAppPath=TargetWebSite/TargetWebApp

Configuration: This is the configuration you will use eg. Debug, Release or a custom one
AllowUntrustedCertificate: You will need this if you do not have a valid certificate on the server
DeployIisAppPath: The name of the target website eg. “Default Web Site/MyWebApp”
TargetWebSite/TargetWebApp: Please consider the different usages below!

Step 2: Get the command line for MSDeploy

Append the parameter “/P:UseMsdeployExe=True” to the msbuild.exe call. If you do so, you will see the call in the console like this:

MSDeployPublish:
Start Web Deploy Publish the Application/package to https:/TargetServer/MsDeploy.axd?site=TargetWebSite …
Running msdeploy.exe.
msdeploy.exe -source:package=’C:\SomeWebProject\obj\Release\Package\SomeWebProject.zip‘ -dest:auto,ComputerName=’https://TargetServer:8172/MsDeploy.axd?site=TargetWebSite‘,UserName=’Username‘,Password=’Password‘,IncludeAcls=’False’,AuthType=’Basic’ -verb:sync -disableLink:AppPoolExtension -disableLink:ContentExtension -disableLink:CertificateExtension -allowUntrusted -retryAttempts=2

Gotcha! This is the important MSDeploy command line call.

Step 3: Get the two things together

now we can split the automatic deployment of MSBuild into 1. create only the package with MSBuild and 2. only deploy with MSDeploy.

msbuild.exe
SomeWebProject.csproj
/P:Configuration=Release
/P:DeployOnBuild=True
/P:CreatePackageOnPublish=True

msdeploy.exe
-source:package=’C:\SomeWebProject\obj\Release\Package\SomeWebProject.zip‘
-dest:auto,ComputerName=’https://TargetServer:8172/MsDeploy.axd?site=TargetWebSite‘,UserName=’Username‘,Password=’Password‘,IncludeAcls=’False’,AuthType=’Basic’
-verb:sync
-disableLink:AppPoolExtension
-disableLink:ContentExtension
-disableLink:CertificateExtension
-allowUntrusted
-retryAttempts=2
-setParam:’IIS Web Application Name’=’TargetWebSite/TargetWebApp‘

Have a nice day.

This is my interpretation:

The colors and the strong reflection is my personal taste.

The .blend file can be downloaded HERE.

While exploring the new features i found two new functions!

First – Import brush textures from a dictionary / single brush textures (without add-on!).
After adding, you will have all your brush textures you choose in the selection box.

You can find many nice brush textures at Pixologic ZBrush Download Central. (The .psd files can be converted to .png files with free converters.)

Second: Brush Overlay
This shows you where your brush would take influence on the mesh.

And also tiling / rotating (angle) of the brush is supported!

i hope you will find this information useful!

Happy blending

This was entirely done with Blender 3D.

Addons:
.) 2D Tracking (Tomato Branch)
.) RotoBezier

The free Footage comes from hollywoodcamerawork.us

The whole process lasts ~4 hours:
(30 min 2d tracking, 15 min compositing, the remaining time: first time ever roto scoping^^)
for the first time i think i was realy fast

i can provide the .blend file if someone want it.

The .blend file can be downloaded here.

You can follow the full guide or skip the optional steps.

1) Open a new Scene, delete the default Cube and add Suzanne (Monkey).

2) Look through your Camera [NUM0] and rotate the Mesh as you want (tap [RKEY] twice for Trackball rotation).

3) Apply the rotation with [CTRL]+[AKEY]. This is needed for the direction of the Threads.

4 opt) Add a Subdivision Surface Modifier (Level 2) to the Mesh and apply it because we need the additional Vertices count.

5 opt) Go into Edit Mode with [TAB], switch to Orthographic View with [NUM5] and to Top View with [NUM7].

6 opt) Now select some random Vertices you can see from above (Top View) with the right mouse button and the [SHIFT] key.

7 opt) Switch to the Object Data in the properties panel, create a new Vertex Group with the plus sign and assign the selection to the Group. Leave the Edit Mode with [TAB].

Now change to the Particles in the Properties Panel. Create a Particle System with the plus sign and change the type to Hair.

9) Tick the Advanced Options Check-box. Now set the amount to about 20 (depends on the selected Vertices), Emit from to Verts (Vertices) and set the velocity parameters (Normal to zero, Z to 1). If you rotate your Viewport now, you will see that the Hairs stands upwards now.

10 opt) Now scroll all the way down to Vertex Groups and expand the Panel. Chose the Group (selected Vertices) for Density. Now we have control where the Hairs are coming from.

11) Change to the Materials in the Properties Panel and create a new Material. You can leave the Settings as they are.

12) Change to the Textures in the Properties Panel and create a new Texture. You can chose the Texture Type Magic for an instant colorized result or chose an Image.


You can now render with [F12] and you will see a hanging Monkey face.

The reason why this works is because the Hairs take over the color from the Material as long as the Material index is set to the Objects Material.

And that’s my render result:

Happy blending

Update: Thanks to Artorp to helping me to understand my mistake – it is NOT a 360° render because blender cannot do this.
But now i have more accurate settings for a better render this way.

The setup is now fairly easy:

• place the camera with horizontal alignment between the objects
• set the focal length to 5.050mm
• enable the panorama option

Next we have to setup the render options:

• In the performance tab extend the Tiles X and Y to 360 and 180.
  (This will increase the render time but reduces the count of artifacts)

With these settings, you get a result like this:

Happy blending

please critique it, i have to know the truth