Basic files for UPBGE in Blender 2.8 experimental build (UPBGE + Eeevee)

Hello folks!

The UPBGE project is going along well. In january this year they uploaded an experimental build for UPBGE + Blender 2.8 (Eeevee).

So,

I decided to create this post to upload some very basic files that aim to test UPBGE’s features.

If someone decide to post inside this topic please don’t forget to specify which version of UPBGE you are using, and to share the .blend file.

My first file is a simple add object file. There is an empty, a sphere, a plane a lamp and a camera. I did a record of what this file does. As you can see by the video there is a little flickering evey time the empty adds a new object. I’m using Blender 2.8 (Eeevee) experimental build (2020-01-29). I’m gonna use the version that is available for download inside the UPBGE website.

Download the .blend file:

https://drive.google.com/file/d/1dlQHb63abvqeQl5VZSCOpq3925yMGAXK/view?usp=sharing

I’m gonna make a copy of my posts inside this topic here:

I suggest everybody to do the same since BlenderArtists lost a lot of posts when it migrated from Vbulletin to Discourse. :wink:

Greetings,

Ortiz

2 Likes

The flicker is now gone after recent fixes

=D

Here Is my build from last week
(win64)*

3 Likes

So glad the BGE is still alive. I’ve been missing it.

3 Likes

Nice to hear that Jacob! Glad to see you here. :slight_smile:

Thank you for that build. Is this windows I suppose?

1 Like

Sure thing! I’m glad too.

1 Like

Here is how to make a porable build for linux


in this video description is loki’s dropbox with recent builds also

https://mega.nz/#F!t9EEFSaS!JPiOPSInCZyU-SW_-rhEOQ

1 Like

Great! Thank you so much! :slight_smile:

New file. Saved in (2020-01-29) version. It is a very simple first person template. Features can be seen in the video.

Blend file here:

1 Like

Hi, for this kindof fps templates, you can try to disable viewport denoiser (render tab > sampling > viewport denoising) to avoid some artifacts and add a fxaa GLSL filter that you can find in text editor > templates > OpenGL shading langage. (The problem is that disabling viewport denoising causes other issues with some eevee’s post processing effects but if you don’t use eevee’s post processing, you should have a better image quality)

1 Like

Thank you for the tip aWeirdOwl! :slight_smile:

Hi

How I can get UPBGE install it as add-on Or as software ?

https://upbge.org/ ( https://mega.nz/folder/k9MW1KiZ#UOKzjh3IQ0GEgjQ6GUc7ug/folder/ZtcDzYYA ) - you install it as a new version of Blender.

i didn’t found any fxaa there. but when i try to run my old fxaa in 0.3 it prints:

GPUShader: compile error:
0(12) : error C7616: global variable gl_TexCoord is removed after version 140
0(26) : error C7616: global function texture2DLod is removed after version 140
0(77) : warning C7533: global variable gl_FragColor is deprecated after version 120

What am i doing wrong? How to fix the error messages?

The errors are deprecation errors - You can either learn GLSL & reconvert your shader, or have someone who knows GLSL to convert the shader.

yea…
I just need to know what to replace gl_FragColor for.

in 0.3, to display depth texture for example:

uniform sampler2D bgl_DepthTexture;

in vec4 bgl_TexCoord;
out vec4 fragColor;

void main()
{
    fragColor = texture(bgl_DepthTexture, bgl_TexCoord.xy);
}
1 Like

me too :sob:

@aWeirdOwl already posted the answer

uniform sampler2D bgl_DepthTexture;

in vec4 bgl_TexCoord;
out vec4 fragColor;

void main()
{
    fragColor = texture(bgl_DepthTexture, bgl_TexCoord.xy);
} 
1 Like

Thank you guys!
converting the filter i noticed the deprecations are highlighted in green. XD

fxaa.glsl

#version 120

uniform sampler2D bgl_RenderedTexture;
uniform float bgl_RenderedTextureWidth;
uniform float bgl_RenderedTextureHeight;

float width = bgl_RenderedTextureWidth;
float height = bgl_RenderedTextureHeight;

in vec4 bgl_TexCoord;
out vec4 fragColor;

float FXAA_SUBPIX_SHIFT = 1.0/4.0;
vec2 rcpFrame = vec2(1.0/width, 1.0/height);
vec4 posPos = vec4(bgl_TexCoord.xy,bgl_TexCoord.xy -(rcpFrame * (0.5 + FXAA_SUBPIX_SHIFT)));


vec3 FxaaPixelShader(
  vec4 posPos, // Output of FxaaVertexShader interpolated across screen.
  sampler2D tex, // Input texture.
  vec2 rcpFrame) // Constant {1.0/frameWidth, 1.0/frameHeight}.
{
/*---------------------------------------------------------*/

    #define FXAA_REDUCE_MIN   (1.0/128.0)
    #define FXAA_REDUCE_MUL   (1.0/8.0)
    #define FXAA_SPAN_MAX     8.0
/*---------------------------------------------------------*/
    vec3 rgbNW = texture2D(tex, posPos.zw, 0.0).xyz;
    vec3 rgbNE = texture2D(tex, posPos.zw + vec2(1.0,0.0)*rcpFrame.xy, 0.0).xyz;
    vec3 rgbSW = texture2D(tex, posPos.zw + vec2(0.0,1.0)*rcpFrame.xy, 0.0).xyz;
    vec3 rgbSE = texture2D(tex, posPos.zw + vec2(1.0,1.0)*rcpFrame.xy, 0.0).xyz;
    vec3 rgbM  = texture2D(tex, posPos.xy,0.0).xyz;
/*---------------------------------------------------------*/
    vec3 luma = vec3(0.299, 0.587, 0.114);
    float lumaNW = dot(rgbNW, luma);
    float lumaNE = dot(rgbNE, luma);
    float lumaSW = dot(rgbSW, luma);
    float lumaSE = dot(rgbSE, luma);
    float lumaM  = dot(rgbM,  luma);
/*---------------------------------------------------------*/
    float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));
    float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));
/*---------------------------------------------------------*/
    vec2 dir;
    dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));
    dir.y =  ((lumaNW + lumaSW) - (lumaNE + lumaSE));
/*---------------------------------------------------------*/
    float dirReduce = max(
        (lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * FXAA_REDUCE_MUL),
        FXAA_REDUCE_MIN);
    float rcpDirMin = 1.0/(min(abs(dir.x), abs(dir.y)) + dirReduce);
    dir = min(vec2( FXAA_SPAN_MAX,  FXAA_SPAN_MAX),
          max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),
          dir * rcpDirMin)) * rcpFrame.xy;
/*--------------------------------------------------------*/
    vec3 rgbA = (1.0/2.0) * (
        texture2D(tex, posPos.xy + dir * (1.0/3.0 - 0.5),0.0).xyz +
        texture2D(tex, posPos.xy + dir * (2.0/3.0 - 0.5),0.0).xyz);
    vec3 rgbB = rgbA * (1.0/2.0) + (1.0/4.0) * (
        texture2D(tex, posPos.xy + dir * (0.0/3.0 - 0.5),0.0).xyz +
        texture2D(tex, posPos.xy + dir * (3.0/3.0 - 0.5),0.0).xyz);
    float lumaB = dot(rgbB, luma);
    if((lumaB < lumaMin) || (lumaB > lumaMax)) return rgbA;
    return rgbB; }

vec4 PostFX(sampler2D tex, vec2 uv)
{
  vec4 c = vec4(0.0);
  vec2 rcpFrame = vec2(1.0/width, 1.0/height);
  c.rgb = FxaaPixelShader(posPos, tex, rcpFrame);
  //c.rgb = 1.0 - texture2D(tex, posPos.xy).rgb;
  c.a = 1.0;
  return c;
}

void main()
{
  vec2 uv = bgl_TexCoord.xy;
  fragColor = PostFX(bgl_RenderedTexture, uv);
}

I still don’t know how this filter works so that I can increase its effect.
I’m having to stack multiple passes to make it noticeable.

in 0.3, there is a builtin SMAA filter (in sampling > check SMAA). Else, in text editor > templates > openGL shading langage, there is an FXAA 2d filter from nvidia adapted for bge.

But with these filters, you won’t get the quality of the filters applied for a static image in eevee (TAA when nothing is moving)