We programmed a hack’n slash (including a one-click inventory, point and click interface and contextual menus) with Python for Blender 2.49b.

CG-free template (download, BSD licence)

Classic project environment :

o Intranet (Process and planning)

o SVN Server

o File Organisation (learned from YoFrankie!)

– World Creation level

– Region Creation level

We have been invited to present it at Blender Conference 2009 in Amsterdam.

Resume

Blender for Game prototyping (Jean Christophe ROMAIN et Gauthier BOAGLIO)

In order to produce its first prototype of a stand alone game, Klakos’s team developed a production pipeline with Blender. In addition to an intranet and a source version control solution, it constitutes a complete tool efficient in a team work context. Blender provides a very good potential on the video game market with tools covering all the tasks needed in a video game production : animation, AI, Python programing language, physics, sounds etc…

We think that one of the biggest strength of Blender is the integrated game engine which allows to visualize and modify complex scenes in real-time. It makes Blender a unique tool in the market. As for us Blender cannot be used in its current state for complex published games because of the way to manage logic bricks, the lack of a full binary exports tool, some Blender features are not reachable from Python and the lighting engine performances.

Blender can find a real place in professional game development studios with several adjustments. We think that plugins allowing connection to commercial game engines could enlarge its use

Because we save painful method to cases that really require it. In other cases, we like to make life easier and faster.

C# relevant features for video game programming :


o Oriented objet language
o Very large number of sources and open sources libraries availables
o Framework class library is rich, well designed and well documented
o No memory adressing issues (comparing to C++)
o Managed code
o Most of the time, memory issues are related to graphisms or IAs, not program execution time

Unity 3D C# programmed demo

Simple game loop, simple AI behavior on Unity navmesh, simple GUI

Click to add mobs in clans or reset game loop.
Bosses spawn randomly (hit harder, more life than mobs). When a clan takes over the other, mobs attacked the enemy flag (flag loss = spawners loss). Winners killed all the enemy mobs.

Unity add on

Vizio + PoolManager 2 Quick Bridge

Description : http://forum.unity3d.com/threads/127709-Free-Source-code-included-Visio-PoolManager2-Quick-bridge
Code (GPL licence) : http://www.klakos.com/Studio/contenus_site/contenu_trie/PM2_Visio1.26_Bridge.unitypackage

Vizio + N GUI Bridge (NGUI activators smartblocks)

Code (GPL licence) : http://www.klakos.com/Studio/contenus_site/contenu_trie/Vizio_NGUI.rar

Unity 3D flash build for web browser. You can move the light with mouse over the active windows, and ogre follows it with eyes.

(consider transparency for shadow casting)

6000+ view sur unify community (MàJ janv. 2012)	Full case study with tutorial and code (LGPL)

Double sided Shader (transparent shadow receiver)

(consider transparency for shadow casting with spot/point lights and directional lights)

2500 + view sur unify community (MàJ janv. 2012)	Full case study with tutorial and code (LGPL)

• * Advanced ShaderLab surface shading for transparency management
• * Acting in “Forward” rendering path and the “ForwardBase” Lightmode
• * Activating shadows from any kind of light (Methods 1 and 2)
• * Compositing a scene in both “Forward” and “Deferred Lighting” views

>>> Downloads

• - PDF version of this article : TransparentShadowReceiver.pdf
• - Unity 3.4.1f5 Demo Project : TransparentShadowReceiver.rar

>>> Prerequisites

Set of lights and scene graph :

[FIG 1]

The scene is composed of 2 lights (a Spot one and a Directional one). Those two lights are supposed to project the shadows of a Sphere on a Plane. The Plane’s Material is set up using the transparent Shader described below.

Note : The Camera dedicated to the rendering of the two objects MUST also have its “Rendering path” parameter set to “Forward”.

>>> Advanced ShaderLab surface shading for transparency management

The “surface” shaders, available in Unity 3 are very simple and powerful (excepted that multi-passes are not allowed – we’ll see it later in this doc.)

Anyway, they are the way I chose to accomplish this work.

Here is the base shader which will be used all along this article. For more details see the previous topic [ARTICLE : Advanced Waving Flag Shader for Unity (Double sided, Alpha shadow support) / SECTION : Advanced ShaderLab surface shading for transparency management].

[CODE] [download file]


SubShader
{
Tags {
"Queue"="AlphaTest"
"IgnoreProjector"="True"
"RenderType"="Transparent"
}
LOD 300
// Main Surface Pass (Handles Spot/Point lights)
CGPROGRAM
#pragma surface surf BlinnPhong alpha vertex:vert fullforwardshadows approxview
half _Shininess;
sampler2D _MainTex;
float4 _Color;
sampler2D _BumpMap;
//sampler2D _ParallaxMap;
float _Parallax;
struct v2f {
V2F_SHADOW_CASTER;
float2 uv : TEXCOORD1;
};
struct Input {
float2 uv_MainTex;
float2 uv_BumpMap;
//float3 viewDir;
};
v2f vert (inout appdata_full v) {
v2f o;
return o;
}
void surf (Input IN, inout SurfaceOutput o) {
// Comment the next 4 following lines to get a standard bumped rendering
// [Without Parallax usage]
/*half h = tex2D (_ParallaxMap, IN.uv_BumpMap).w;
float2 offset = ParallaxOffset (h, _Parallax, IN.viewDir);
IN.uv_MainTex += offset;
IN.uv_BumpMap += offset;*/
fixed4 tex = tex2D(_MainTex, IN.uv_MainTex);
o.Albedo = tex.rgb * _Color.rgb;
o.Gloss = tex.a;
o.Alpha = tex.a * _Color.a;
//clip(o.Alpha - _Cutoff);
o.Specular = _Shininess;
o.Normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
}
ENDCG
}


[FIG 2]

With this quite simple Shader, we get a perfect rendering of the Spot/Point lights, but nothing at all concerning DIRECTIONAL lights. The goal is to make the Plane able to also receive shadows from the second ones.

>>> Acting in “Forward” rendering path and the “ForwardBase” Lightmode

As said earlier, the Camera dedicated to the rendering of the two objects must have its “Rendering path” parameter set to “Forward”.

The Pass Tag “Lightmode” can take different values. The one we are interested in is the “ForwardBase” one which is “Used in Forward rendering, ambient, main directional light and vertex/SH lights are applied”, according to the Unity documentation [SL-PassTags].

But let’s have a test by adding this tag to our current shader :

[CODE] [download file]


SubShader
{
Tags {
"Queue"="AlphaTest"
"IgnoreProjector"="True"
"RenderType"="Transparent"
"LightMode" = "ForwardBase"
}
LOD 300
// Main Surface Pass (Handles Spot/Point lights)
CGPROGRAM
#pragma surface surf BlinnPhong alpha vertex:vert fullforwardshadows approxview
.
.
.
ENDCG
}


[FIG 3]

We get – as expected – the shadows related to the Directional light and nothing from the Spot one.

Fine, but we need all the shadows.

>>> Activating shadows from any kind of light (Methods 1 and 2)

Well, the following aims to explain two different methods to mix all the types of shadows together.
Those methods have benefits and drawbacks, of course…

>> The “Doubled Material” Method :

It consists in creating two Materials (one using the first version of the shader and the other using the second/Forward one). Then, set up the MeshRenderer of the Plane with those Materials.

[FIG 4.1]

[FIG 4.2]

Benefits : Easy. Free to redo the whole process on any other base shader.


Drawbacks : The two shaders are a bit boring to manipulate because of the need for keeping the same values for each parameter between them. They are redundant and we get two Materials where we could have only one. It is also quite hard to have a fine customization of the light and shadows intensity.


>> The “Blending Shadows” Method :

With this one, we get only one shader, by blending the Directional Light to our very first Shader (made in an additional Pass).

[CODE]


SubShader
{
Tags {
"Queue"="AlphaTest"
"IgnoreProjector"="True"
"RenderType"="Transparent"
}
LOD 300
// Main Surface Pass (Handles Spot/Point lights)
CGPROGRAM
#pragma surface surf BlinnPhong alpha vertex:vert fullforwardshadows approxview
.
.
.
ENDCG
// Shadow Pass : Adding the shadows (from Directional Light)
// by blending the light attenuation
Pass {
Blend SrcAlpha OneMinusSrcAlpha
Name "ShadowPass"
Tags {"LightMode" = "ForwardBase"}
CGPROGRAM
#pragma exclude_renderers xbox360
#pragma debug
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile_fwdbase
#pragma fragmentoption ARB_fog_exp2
#pragma fragmentoption ARB_precision_hint_fastest
#include "UnityCG.cginc"
#include "AutoLight.cginc"
struct v2f {
float2 uv_MainTex : TEXCOORD1;
float4 pos : SV_POSITION;
LIGHTING_COORDS(3,4)
float3 lightDir;
};
float4 _MainTex_ST;
sampler2D _MainTex;
float4 _Color;
float _ShadowIntensity;
v2f vert (appdata_full v)
{
v2f o;
o.pos = mul (UNITY_MATRIX_MVP, v.vertex);
o.lightDir = ObjSpaceLightDir( v.vertex );
TRANSFER_VERTEX_TO_FRAGMENT(o);
return o;
}
float4 frag (v2f i) : COLOR
{
float atten = LIGHT_ATTENUATION(i);
half4 c;
c.rgb = 0;
c.a = (1-atten) * _ShadowIntensity;
return c;
}
ENDCG
}
}


Here we simply add a specific Pass for Directional Light rendering. This is done by blending the “Light Attenuation” to the first CGPROGRAM part which constitutes a first Pass (using Surface features).

For “alpha blending”, we use “ Blend SrcAlpha OneMinusSrcAlpha”.
See [SL-Blend]

Note : Remember that Surface Shaders allow only one Surface Pass.

Note : “_ShadowIntensity” parameter has been added to help fine customization of shadows intensity.

[FIG 5]

Problem : The Directional light shadow overlaps the transparent areas of our ARGB texture.


Solution : To correct the shadow intensity by picking up the alpha informations from the alpha channel of the Main Texture…

Two steps :

• -  ”TRANSFORM_TEX” calculates the uv coordinates for the tiling and offset set up for the texture (to load the right pixel informations from the Texture)
• -   “* tex2D(_MainTex, i.uv_MainTex).a” Multiplies the shadow intensity by the alpha channel of the Texture

[CODE] [download file]


v2f vert (appdata_full v)
{
v2f o;
o.uv_MainTex = TRANSFORM_TEX(v.texcoord, _MainTex);
o.pos = mul (UNITY_MATRIX_MVP, v.vertex);
o.lightDir = ObjSpaceLightDir( v.vertex );
TRANSFER_VERTEX_TO_FRAGMENT(o);
return o;
}
float4 frag (v2f i) : COLOR
{
float atten = LIGHT_ATTENUATION(i);
half4 c;
c.rgb = 0;
c.a = (1-atten) * _ShadowIntensity *
(tex2D(_MainTex, i.uv_MainTex).a);
return c;
}


[FIG 6]

Now it looks good.

>>> Compositing a scene with both “Forward” and “Deferred Lighting” views

Finally, we can play with 2 Cameras : the first one with “Rendering path” set to “Forward”, and the second one set to “Deferred Lighting”. And juggle with the layering of the objects to combine usual shadows computing with our “Forward” ones.

[FIG 7]

This is obtained with left Sphere+Plane in layer1, and right Sphere+Plane in layer2. Respectively, a Camera in Forward mode (and “Clear Flags” = “Depth Only”) and second Camera in Deferred mode (and “Clear Flags” = “Skybox”).




Note : An other way to do the trick could have been to keep the whole scene in “Forward rendering path” and to customize the “Non-Forward” shaders to enable them to “fullforwardshadows” in their “#pragma surface” line. Here is an example with the “Normal-Diffuse” one : [download file].




Anyways, the “Forward rendering path” is a lot more compatible with smaller hardware configurations. So you’re not loosing your time by working in this mode !
[RenderingPaths]

Big Conclusion

Well, nothing more actually…

Hope this will help,

and don’t forget to post feedbacks (I need you to make this doc. better)

Thanks !

Cette note n’est pas disponible en French, même si c’est marqué que si, juste aprés.