Posts by paulevs

Quote from sharkbitefischer

Make it brown fog and call it smog lol

And a bit more alien-looking sky: magenta

Attempt to create some sort of warm weather (I called it Hot Red) with reddish fog near horizon

Some small experiments with modern Rising World game engine. This is very simple example of custom weather. I named it "Green Fog", as the main goal was to create, well, green fog. I also added rain, so it looks like "acid rain" or "post apocalyptic" weather. The fog shade is mixing with sky and creates some sort of interesting gradient

Now building have floors (19), I also started remaking the central staircase, hi to 32 fps (in most cases 48-50, there are too many construction elements)

Hi, when I experimented with palette colors I noticed some things:

- There is no orange color (but there is red and yellow);

- Some pale colors are very similar.

Here are bricks in different colors to illustrate current palette:

Will it be a good idea to correct palette and make more interesting colors? I made this simple palette as my suggestion, it contains 24 colors and have mostly useful ones (based on palette from here)

Quote from Deirdre

paulevs Wonderful buildings.

In the past, such priciously work required hours of calculation and hours of construction.
What strikes me is the different texture of the sloping window. I think you can adjust this texture as well. For me personally, the new building method is taking a lot longer than before, i'm excited about what architecture is suddenly being seen.

For me modern system is not very time consuming, actually I didn't build advanced things in Java RisingWorld and used only full blocks. For me new system allows me easily implement complex things, despite it hasn't any copy/paste tool. Radial menu and pivot system with rotation/scaling really helps a lot

About calculations - to build this curve I used some Excel calculations to find correct angles for each segment, probably it is simpler than calculations in old version (as I never build with resizeable blocks I don't know), but most building part were created by visual block placing

I think this problems are resolved (at least for me)

Quote from red51

This is unfortunately a bug in Unitys new input system The alt key is still considered actuated after switching to the desktop, resulting in slow movement. You can solve this by just pressing alt again.

Didn't know that, thanks you very much

Quote from red51

Maybe you could send us a report, that would be extremely helpful To do that, please launch the game, then quit it again (to cause a crash to happen), then launch the game again, open the console and type "report". This brings up the report dialog which includes the last log (which may contain more information about the crash).

Done

Quote from red51

After sending the report, you could try this to see if this fixes the issue: Please open the config.properties file in the game directory and add this line somewhere: Game_NoAbort=True, then save the file and run the game. Does it still crash on exit?

This worked, now game is not crashing on exit, thank you! Thanks for the great game!

There is not a lot of progression since last screenshots, I failed some structure parts a bit and some things like central staircase is not designed properly, but here is what I have now:

Central staircase is not finished, I want to redesign it and made its support from bricks instead of metal

Just a good volumetric light image

Really great glass shading from new version (There will be no glass in this arches, I just used them to test new glass panes. But windows in building will have glass)

These bugs I faced in new Unity version. I don't know if someone already reported them, but they still exists in latest update, and existed 3 versions earlier.

(The game itself runs fast and smoothly on almost any settings)

1. Bug with player movement:

When I'm playing new Unity version sometimes I see this strange bug. If you will pause the game for a while and/or alt+tab window to another one (for some time), and then return back - the player sometimes move incredibly slowly. I faced this bug in creative mode when the player is no flying, if player starts to fly - it will have normal speed, but if it will stop - the bug happens again. After certain amount of time the bug may disappear or not.

2. Bug with console:

If you start the game and type something into the console - you can easily remove letters with backspace if you have a mistake. But if you will alt+tab window and try this again you may notice that it is impossible to remove letters. You can type more letters, but you cant remove them.

3. Bug with game exit:

On game exit independently from what point it was done (from world or main menu) the game will crash after correct world saving.

My system spec:

- Windows 7 (Professional), 64 bit;

- Intel Core I7-7700;

- Nvidia GeForce GTX 980.

Building progress - outer frames, next floor of building support and 8 supporting arc-boutants. Total building height is ~250 meters.

Screenshots:

Here is how I calculated the curve based on fixed-length part and different angles (in the final version it was scaled by 16):

I'm trying to start something like "mega building" project. I'm using architectural art made by Arthur Vladimirovich Skizhali-Weiss ("Mysterious structures in the desert") as a reference. Here is the first floor of this building (~64 meters in radius and ~20 meters in height):

And the reference:

Updated shader variant - now it uses more colors to detect large plant movements (branches on trees) and have smooth movement for small plants and leaves

Shader "Custom/PlantShader" {
    Properties {
        _MainTex ("Texture (RGBA)", 2D) = "white" {}
        _MaskTex ("Mask (RGB)", 2D) = "black" {}
        _NormalMap ("Normal Map (RGB)", 2D) = "black" {}
        _Cutoff("Alpha Cutoff", Range(0.0, 0.9)) = 0.5
    }
    SubShader {
        Tags {"Queue"="AlphaTest" "IgnoreProjector"="True" "RenderType"="TransparentCutout"}
        LOD 200
        Cull Off 
        
        CGPROGRAM
        #pragma surface surf Plant alphatest:_Cutoff addshadow vertex:vert
        #pragma target 3.0
        
        sampler2D _MainTex, _MaskTex, _NormalMap;
        
        struct Input {
            float2 uv_MainTex;
        };
        
        // Custom surface structure
        struct SurfaceOutputCustom {
            fixed3 Albedo;
            fixed3 Normal;
            fixed3 Emission;
            fixed3 Mask;
            half Specular;
            fixed Gloss;
            fixed Alpha;
        };
        
        // Leaves and plant waving
        void vert (inout appdata_full v) {
            float intensity = v.color.g * 2.0;
            float3 worldPos = mul(unity_ObjectToWorld, float4(v.vertex.xyz, 1)).xyz;
            float offset = _Time.x * 13.0 + worldPos.z * 0.1 + worldPos.y * 0.15;
            float big_dx = sin(offset) * intensity;
            float big_dy = cos(offset) * intensity;
            
            intensity = v.color.r * 0.2;
            offset = worldPos.z * 0.5 + worldPos.x * 0.5 + worldPos.y;
            float dx = sin(_Time.x * 100.0 + offset) * intensity;
            float dz = sin(_Time.x * 75.0 + offset) * intensity;
            float dy = sin(_Time.x * 50.0 + offset) * intensity;
            
            v.vertex.x += dx + big_dx;
            v.vertex.z += dz * 0.2;
            v.vertex.y += dy + big_dy;
        }
        
        // Texture & Mask input, normals
        void surf(Input IN, inout SurfaceOutputCustom o) {
            fixed4 color = tex2D(_MainTex, IN.uv_MainTex);
            fixed4 mask = tex2D(_MaskTex, IN.uv_MainTex);
            fixed4 normal = tex2D(_NormalMap, IN.uv_MainTex);
            o.Albedo = color.rgb;
            o.Alpha = color.a;
            o.Mask = mask.rgb;
            o.Normal = UnpackNormal(normal);
            o.Emission = mask.g * color.rgb;
        }
        
        // Light calculations - surface, luminocity, sub-surface scattering
        half4 LightingPlant(SurfaceOutputCustom s, half3 lightDir, half atten) {
            fixed3 mask = s.Mask;
            half NdotL = dot(s.Normal, lightDir);
            half light = max(_LightColor0.rgb * (NdotL * atten), _LightColor0.rgb * mask.r * atten);
            //light = max(light, mask.g);
            
            half4 color;
            color.rgb = s.Albedo * light;
            color.a = s.Alpha;
            return color;
        }
        
        ENDCG
    }
}

Red color marks leaves movement, green color - branch movement (it was mapped as distance to zero)

import math

pmax = 0.0

objData = bpy.context.active_object.data
vertexes = objData.vertices
polygons = objData.polygons
colors = objData.vertex_colors[0].data

for polygon in polygons:
    for li in polygon.loop_indices:
        loop = objData.loops[li]
        vi = loop.vertex_index
        vertex = vertexes[vi]
        pos = vertex.co
        if (pmax < pos.x):
            pmax = pos.x
        if (pmax < pos.y):
            pmax = pos.y
        if (pmax < pos.z):
            pmax = pos.z

for polygon in polygons:
    for li in polygon.loop_indices:
        loop = objData.loops[li]
        vi = loop.vertex_index
        vert = vertexes[vi]
        vertcol = colors[li]
        if vert.co.z > 0:
            x2 = vert.co.x * vert.co.x
            y2 = vert.co.y * vert.co.y
            z2 = vert.co.z * vert.co.z
            dist = math.sqrt(x2 + y2 + z2) / pmax
            vertcol.color[1] = dist

The latest compiled version

As it is impossible to see how mushrooms are glowing - here is a small screenshot of the same scene with only one point light and without ambient lights

This is a simple demonstration of plant shader made by me in Unity. All plants models were made hastily in Blender and exported as .dae into Unity (to save vertex colors used as wind movement markers). Trees used sub-surface scattering and wind mask (the same for grass), mushrooms - glowing mask, the shader is the same for all plants

Shader "Custom/PlantShader" {
    Properties {
        _MainTex ("Texture (RGBA)", 2D) = "white" {}
        _MaskTex ("Mask (RGB)", 2D) = "black" {}
        _NormalMap ("Normal Map (RGB)", 2D) = "black" {}
        _Cutoff("Alpha Cutoff", Range(0.0, 0.9)) = 0.5
    }
    SubShader {
        Tags {"Queue"="AlphaTest" "IgnoreProjector"="True" "RenderType"="TransparentCutout"}
        LOD 200
        Cull Off 
        
        CGPROGRAM
        #pragma surface surf Plant alphatest:_Cutoff addshadow vertex:vert
        #pragma target 3.0
        
        sampler2D _MainTex, _MaskTex, _NormalMap;
        
        struct Input {
            float2 uv_MainTex;
        };
        
        // Custom surface structure
        struct SurfaceOutputCustom {
            fixed3 Albedo;
            fixed3 Normal;
            fixed3 Emission;
            fixed3 Mask;
            half Specular;
            fixed Gloss;
            fixed Alpha;
        };
        
        // Leaves and plant waving
        void vert (inout appdata_full v) {
            float intensity = v.color.r * 0.3;
            float dx = sin(_Time.x * 100.0 + v.vertex.z + v.vertex.y * 2) * intensity;
            float dz = sin(_Time.x * 73.3 + v.vertex.x + v.vertex.y * 2) * intensity;
            v.vertex.x += dx;
            v.vertex.z += dz;
        }
        
        // Texture & Mask input, normals
        void surf(Input IN, inout SurfaceOutputCustom o) {
            fixed4 color = tex2D(_MainTex, IN.uv_MainTex);
            fixed4 mask = tex2D(_MaskTex, IN.uv_MainTex);
            fixed4 normal = tex2D(_NormalMap, IN.uv_MainTex);
            o.Albedo = color.rgb;
            o.Alpha = color.a;
            o.Mask = mask.rgb;
            o.Normal = UnpackNormal(normal);
            o.Emission = mask.g * color.rgb;
        }
        
        // Light calculations - surface, luminocity, sub-surface scattering
        half4 LightingPlant(SurfaceOutputCustom s, half3 lightDir, half atten) {
            fixed3 mask = s.Mask;
            half NdotL = dot(s.Normal, lightDir);
            half light = max(_LightColor0.rgb * (NdotL * atten), _LightColor0.rgb * mask.r * atten);
            //light = max(light, mask.g);
            
            half4 color;
            color.rgb = s.Albedo * light;
            color.a = s.Alpha;
            return color;
        }
        
        ENDCG
    }
}

Unity Project Sources

Assembled exe (can be used as screensaver)

Hi to everyone, some time ago I asked a question about the API for plants. As API of such kind is not implemented yet I listed a small suggestions about plant API that can be possibly added to allow creating custom plants with plugins or modify existing plants (probably) here.

This is a list of how plant can be defined:

• Plants have a unique ID by type (with key set plugin-plant-name -> integer number) if Rising World on Unity uses plant IDs like Java version. This tale will aloow safely add and remove plugins with plants;
• Any plant can be defined as a list of mesh objects (probably in OBJ format);
• Each plant have a vertex color information how wind should be applied to it (for example – red color gradient);
• Each plant has an instance of shader with texture mask (single texture with 3 channels) for sub-surface scattering (leaves, red channel), glowing parts (for plants that can glow, green channel) and refracted parts (blue channel);
• Plant can defile its LOD (for example LOD1 and LOD2) to improve game performance, the most distant LOD is a simple geometry with plant image and it can be generated by the game itself;
• Plants can have a specific events like cutting event to make possible change default plant behavior to something unique or add additional functionality (like collecting rubber from Hevea or collecting fruits);
• Plants can be one of 3 suggested types:

Tree Plant (Cuttable Plant)

• Can be cutted with axes or other tools (probably the tool can be defined in plant to allow users create custom tools to cut plants);
• Will drop its content after cutting and leave a stump;
• Stump can be uprooted and can define its drop;
• Models are stored in a list of 3 separate lists (or in multi-indexed array) – random variants of upper parts, stumps and full for each plant age, all 3 lists have the same length and parts have the same indecies to make cutting operation smooth (without model changing);
• Drops will be scattered across upper plant model part.

Bush Plant (Collectable plant)

• A small plant that will be collected;
• Models are stored in a list of lists (or in multi-indexed array) – random variants for each age.

Grass Plant (Ambient Plant)

• A small plant that will be added to grass material depending on biome;
• Is a 2D texture with defined size;
• Couldn’t be collected.

How plant shader can be organized:

• All plants can use the same shader with complex behavior;
• Texture mask for sub-surface scattering (leaves, red channel), glowing parts (for plants that can glow, green channel) and refracted parts (blue channel). This will alow make plants of almost any kind – from bioluminescent mushrooms (which are technically not plants but can be defined in this way) to any kind of tree.

Sub-surface scattering

This is a common shader technique for thin plant parts like leaves as they will scatter light. There are many different approaches on it

Wind mask

Color/Colors baked inside model vertices, colors can indicate different reaction on wind

I hope you enjoy the idea of such API, discussion and criticism are welcome

Small round house from bricks, copper, concrete & wood (no furniture)

Small brick arch (my first attempt to build something good in Rising World and test of new building system). There are some UV issues on cylinder meshes, I don't know is this a bug or intended behavior. I think I will try to build something bigger in this style

Quote from yahwho

I mean, heightmaps and noise need to be generated and in themselves aren't algorithms, they are the results of an algorithm.

Yes, they also need an algorithm, in most cases its Perlin or Simplex noises with some modifications. On the other hand stochatic texturing can use real world images data (like in example above), which can make fast and realistic terrain.

You also mentioned sine wave with Perlin noise, is this some kind of Perlin noise modification, or it is more complicated? Are there any good articles about it?