Own map with "magic marking" over TextureArray

I’m tinkering with my own map.

I still use basics, still no lighting effects. The exercises from the beginner’s documentation and here from the forum let me build a first presentable version.

The most important hint from Paul was: Use TextureArray for this task!
i’m still busy, the attempts without TextureArray to cut back.

At this point I would like to thank Paul and other for the quick answers here in the forum.

Video:

The heart of the marking is this snippet of code from the frag-shader:

``````
#if defined(HAS_MAGICMARKINDEX1) || defined(HAS_MAGICMARKINDEX2)
vec4 worldPos = g_WorldMatrix  * vec4(position, 1.0);
float rP;
float rR;
float reduction;
#endif
#if defined(HAS_MAGICMARKMAP) && defined(HAS_MAGICMARKINDEX1)
float mark1_x=(m_MagicMarkPos1.x  - worldPos.x) / m_MagicMarkHalfSize1  ;
float mark1_z=(m_MagicMarkPos1.z  - worldPos.z) / m_MagicMarkHalfSize1  ;
float mark1_y=(m_MagicMarkPos1.y  - worldPos.y) / 2.0 ;
rP = mark1_x*mark1_x + mark1_z*mark1_z;
rR = rP + mark1_y*mark1_y;
reduction = (rP > 0.0001) ? sqrt(rR/rP) : 1.0;
// multiplication with reduction,
// because the faster out of the range [0, 1[ the smaller the image.
mark1_x *= reduction;
mark1_z *= reduction;
vec3 mark1_texCoord = vec3(
(mark1_x*m_MagicMarkCos1 - mark1_z*m_MagicMarkSin1)/2.0 + 0.5,
(mark1_x*m_MagicMarkSin1 + mark1_z*m_MagicMarkCos1)/2.0 + 0.5,
m_MagicMarkIndex1
);
vec4 mark1_color = (mark1_texCoord.x>=0.0 && mark1_texCoord.x<1.0 && mark1_texCoord.y>=0.0 && mark1_texCoord.y<1.0)
?texture2DArray(m_MagicMarkMap, mark1_texCoord)
:vec4(0.0);
color =max(color,mark1_color*mark1_color.a + color*(1.0-mark1_color.a));
#endif
#if defined(HAS_MAGICMARKMAP) && defined(HAS_MAGICMARKINDEX2)
float mark2_x=(m_MagicMarkPos2.x  - worldPos.x) / m_MagicMarkHalfSize2  ;
float mark2_z=(m_MagicMarkPos2.z  - worldPos.z) / m_MagicMarkHalfSize2  ;
float mark2_y=(m_MagicMarkPos2.y  - worldPos.y) / 2.0 ;
rP = mark2_x*mark2_x + mark2_z*mark2_z;
rR = rP + mark2_y*mark2_y;
reduction = (rP > 0.0001) ? sqrt(rR/rP) : 1.0;
// multiplication with reduction,
// because the faster out of the range [0, 1[ the smaller the image.
mark2_x *= reduction;
mark2_z *= reduction;
vec3 mark2_texCoord = vec3(
(mark2_x*m_MagicMarkCos2 - mark2_z*m_MagicMarkSin2)/2.0 + 0.5,
(mark2_x*m_MagicMarkSin2 + mark2_z*m_MagicMarkCos2)/2.0 + 0.5,
m_MagicMarkIndex2
);
vec4 mark2_color = (mark2_texCoord.x>=0.0 && mark2_texCoord.x<1.0 && mark2_texCoord.y>=0.0 && mark2_texCoord.y<1.0)
?texture2DArray(m_MagicMarkMap, mark2_texCoord)
:vec4(0.0);
color =max(color,mark2_color*mark2_color.a + color*(1.0-mark2_color.a));
#endif
``````

The MaterialParameters are:

``````
TextureArray MagicMarkMap   //  Pictures
Vector3 MagicMarkPos1       //  x-y-z in 3d space E.G.: shootables.collideWith(ray, results);
Float MagicMarkIndex1       //  Index of Texture, clear Param == mark is off
Float MagicMarkSin1         //  Rotate mark
Float MagicMarkCos1         //  Rotate mark
Float MagicMarkHalfSize1    //  Size / 2.0f
Vector3 MagicMarkPos2       //  x-y-z in 3d space E.G.: shootables.collideWith(ray, results);
Float MagicMarkIndex2       //  Index of Texture, clear Param == mark is off
Float MagicMarkSin2         //  Rotate mark
Float MagicMarkCos2         //  Rotate mark
Float MagicMarkHalfSize2    //  Size / 2.0f
``````
4 Likes

If I in the shader already retract the position in the 3d space, then the implementation of the nebulization is almost forced:

I just have to calculate the distance to the camera to know the intensity of the cloud. And since I also know “y”, I can represent the cloud as a gradient. Dark and somewhat moddy below, rather light gray above.

The heart of the fog is this snippet of code from the frag-shader:

``````    #if defined(HAS_FOG) || defined(HAS_MAGICMARKMAP) || defined(HAS_MAGICMARKINDEX1) || defined(HAS_MAGICMARKINDEX2)
vec4 worldPos = g_WorldMatrix  * vec4(position, 1.0);
float rP;
float rR;
float reduction;
#endif
``````

(…)

``````
#ifdef HAS_FOG
float fog_x=  m_FogCamPos.x  - worldPos.x;
float fog_z=  m_FogCamPos.z  - worldPos.z;
float fog_y=  max(0.0,min(1.0, worldPos.y / m_FogTop));
vec4 fog_color = m_FogStartColorUp*fog_y + m_FogStartColor0*(1.0-fog_y);
rP = max(0.0, fog_x*fog_x + fog_z*fog_z - m_FogStartDistanceSqr);
rR = min(1.0, rP / m_FogDistanceSqr);
color =fog_color*rR + color*(1.0-rR);
#endif
``````

The new MaterialParameters are:

``````
Vector3 FogCamPos           //  x-y-z camera position in 3d space, clear Param == fog is off
Float FogStartDistanceSqr   //  Start distance ^2
Color FogStartColor0        //  Start color on y == 0
Float FogTop                //  y of FogStartColorUp
Color FogStartColorUp       //  Start color on y == FogTop
Float FogDistanceSqr        //  distance ^2
``````
3 Likes

Claim:
But with the fog I could also implement LOD. Everything behind the fog just needs vertices. No texCoord. No color. And the shader would also be thin, without Textures:

``````        vec4 worldPos = g_WorldMatrix  * vec4(position, 1.0);

float fog_y=  max(0.0,min(1.0, worldPos.y / m_FogTop));
color = m_FogStartColorUp*fog_y + m_FogStartColor0*(1.0-fog_y);
``````

Question: Is such a LOD solution for rooms behind the fog worthwhile ?