SkyboxをCubemapに設定すると太陽が表示されなくなる

Question

Skyboxを作ったものに変更したところ(シェーダはSkybox/Cubemap)、
ゲームカメラに太陽が表示されなくなってしまいました。

その場でSkyboxをデフォルトのものに戻すと太陽が表示されるので、
他の環境は関係ないと思います。

このSkyboxで太陽を表示させたいのですが、
どなたかSkyboxについて詳しい方回答お願いします。

####追記
https://www.reddit.com/r/Unity3D/comments/721ctv/standard_skybox_directional_light_results_in_an/
このSkyboxは太陽を描写する処理が含まれていないようなのですが、代わりに良いものがあれば教えていただければ嬉しいです。
スカイボックスのテクスチャはpng１枚です。

Answer 1

パート2

				float far = 0.0;
				half3 cIn, cOut;

				if(eyeRay.y >= 0.0)
				{
					// Sky
					// Calculate the length of the "atmosphere"
					far = sqrt(kOuterRadius2 + kInnerRadius2 * eyeRay.y * eyeRay.y - kInnerRadius2) - kInnerRadius * eyeRay.y;

					float3 pos = cameraPos + far * eyeRay;

					// Calculate the ray's starting position, then calculate its scattering offset
					float height = kInnerRadius + kCameraHeight;
					float depth = exp(kScaleOverScaleDepth * (-kCameraHeight));
					float startAngle = dot(eyeRay, cameraPos) / height;
					float startOffset = depth*scale(startAngle);

					// Initialize the scattering loop variables
					float sampleLength = far / kSamples;
					float scaledLength = sampleLength * kScale;
					float3 sampleRay = eyeRay * sampleLength;
					float3 samplePoint = cameraPos + sampleRay * 0.5;

					// Now loop through the sample rays
					float3 frontColor = float3(0.0, 0.0, 0.0);
					// Weird workaround: WP8 and desktop FL_9_3 do not like the for loop here
					// (but an almost identical loop is perfectly fine in the ground calculations below)
					// Just unrolling this manually seems to make everything fine again.
					//for(int i=0; i<int(kSamples); i++)
					{
						float height = length(samplePoint);
						float depth = exp(kScaleOverScaleDepth * (kInnerRadius - height));
						float lightAngle = dot(_WorldSpaceLightPos0.xyz, samplePoint) / height;
						float cameraAngle = dot(eyeRay, samplePoint) / height;
						float scatter = (startOffset + depth*(scale(lightAngle) - scale(cameraAngle)));
						float3 attenuate = exp(-clamp(scatter, 0.0, kMAX_SCATTER) * (kInvWavelength * kKr4PI + kKm4PI));
						frontColor += attenuate * (depth * scaledLength);
						samplePoint += sampleRay;
					}
					{
						float height = length(samplePoint);
						float depth = exp(kScaleOverScaleDepth * (kInnerRadius - height));
						float lightAngle = dot(_WorldSpaceLightPos0.xyz, samplePoint) / height;
						float cameraAngle = dot(eyeRay, samplePoint) / height;
						float scatter = (startOffset + depth*(scale(lightAngle) - scale(cameraAngle)));
						float3 attenuate = exp(-clamp(scatter, 0.0, kMAX_SCATTER) * (kInvWavelength * kKr4PI + kKm4PI));
						frontColor += attenuate * (depth * scaledLength);
						samplePoint += sampleRay;
					}

					// Finally, scale the Mie and Rayleigh colors and set up the varying variables for the pixel shader
					cIn = frontColor * (kInvWavelength * kKrESun);
					cOut = frontColor * kKmESun;
				}
				else
				{
					// Ground
					far = (-kCameraHeight) / (min(-0.001, eyeRay.y));

					float3 pos = cameraPos + far * eyeRay;

					// Calculate the ray's starting position, then calculate its scattering offset
					float depth = exp((-kCameraHeight) * (1.0/kScaleDepth));
					float cameraAngle = dot(-eyeRay, pos);
					float lightAngle = dot(_WorldSpaceLightPos0.xyz, pos);
					float cameraScale = scale(cameraAngle);
					float lightScale = scale(lightAngle);
					float cameraOffset = depth*cameraScale;
					float temp = (lightScale + cameraScale);

					// Initialize the scattering loop variables
					float sampleLength = far / kSamples;
					float scaledLength = sampleLength * kScale;
					float3 sampleRay = eyeRay * sampleLength;
					float3 samplePoint = cameraPos + sampleRay * 0.5;

					// Now loop through the sample rays
					float3 frontColor = float3(0.0, 0.0, 0.0);
					float3 attenuate;
					//for(int i=0; i<int(kSamples); i++) // Loop removed because we kept hitting SM2.0 temp variable limits. Doesn't affect the image too much.
					{
						float height = length(samplePoint);
						float depth = exp(kScaleOverScaleDepth * (kInnerRadius - height));
						float scatter = depth*temp - cameraOffset;
						attenuate = exp(-clamp(scatter, 0.0, kMAX_SCATTER) * (kInvWavelength * kKr4PI + kKm4PI));
						frontColor += attenuate * (depth * scaledLength);
						samplePoint += sampleRay;
					}

					cIn = frontColor * (kInvWavelength * kKrESun + kKmESun);
					cOut = clamp(attenuate, 0.0, 1.0);
				}

				#if SKYBOX_SUNDISK == SKYBOX_SUNDISK_HQ
					o.vertexForSun = -eyeRay;
				#elif SKYBOX_SUNDISK == SKYBOX_SUNDISK_SIMPLE
					o.rayDir = half3(-eyeRay);
				#else
					o.skyGroundFactor = -eyeRay.y / SKY_GROUND_THRESHOLD;
				#endif

				#if SKYBOX_SUNDISK != SKYBOX_SUNDISK_NONE
					// The sun should have a stable intensity in its course in the sky. Moreover it should match the highlight of a purely specular material.
					// This matching was done using the standard shader BRDF1 on the 5/31/2017
					// Finally we want the sun to be always bright even in LDR thus the normalization of the lightColor for low intensity.
					half lightColorIntensity = clamp(length(_LightColor0.xyz), 0.25, 1);
					#if SKYBOX_SUNDISK == SKYBOX_SUNDISK_SIMPLE
						o.sunColor = kSimpleSundiskIntensityFactor * saturate(cOut * kSunScale) * _LightColor0.xyz / lightColorIntensity;
					#else // SKYBOX_SUNDISK_HQ
						o.sunColor = kHDSundiskIntensityFactor * saturate(cOut) * _LightColor0.xyz / lightColorIntensity;
					#endif
				#endif

				#if defined(UNITY_COLORSPACE_GAMMA) && SKYBOX_COLOR_IN_TARGET_COLOR_SPACE
					#if SKYBOX_SUNDISK != SKYBOX_SUNDISK_NONE
						o.sunColor = sqrt(o.sunColor);
					#endif
				#endif

				return o;
			}

			// Calculates the Mie phase function
			half getMiePhase(half eyeCos, half eyeCos2)
			{
				half temp = 1.0 + MIE_G2 - 2.0 * MIE_G * eyeCos;
				temp = pow(temp, pow(_SunSize,0.65) * 10);
				temp = max(temp,1.0e-4); // prevent division by zero, esp. in half precision
				temp = 1.5 * ((1.0 - MIE_G2) / (2.0 + MIE_G2)) * (1.0 + eyeCos2) / temp;
				#if defined(UNITY_COLORSPACE_GAMMA) && SKYBOX_COLOR_IN_TARGET_COLOR_SPACE
					temp = pow(temp, .454545);
				#endif
				return temp;
			}

			// Calculates the sun shape
			half calcSunAttenuation(half3 lightPos, half3 ray)
			{
				#if SKYBOX_SUNDISK == SKYBOX_SUNDISK_SIMPLE
					half3 delta = lightPos - ray;
					half dist = length(delta);
					half spot = 1.0 - smoothstep(0.0, _SunSize, dist);
					return spot * spot;
				#else // SKYBOX_SUNDISK_HQ
					half focusedEyeCos = pow(saturate(dot(lightPos, ray)), _SunSizeConvergence);
					return getMiePhase(-focusedEyeCos, focusedEyeCos * focusedEyeCos);
				#endif
			}

			fixed4 frag (v2f i) : SV_Target
			{
				// if y > 1 [eyeRay.y < -SKY_GROUND_THRESHOLD] - ground
				// if y >= 0 and < 1 [eyeRay.y <= 0 and > -SKY_GROUND_THRESHOLD] - horizon
				// if y < 0 [eyeRay.y > 0] - sky
				#if SKYBOX_SUNDISK == SKYBOX_SUNDISK_HQ
					half3 ray = normalize(i.vertexForSun.xyz);
					half y = ray.y / SKY_GROUND_THRESHOLD;
				#elif SKYBOX_SUNDISK == SKYBOX_SUNDISK_SIMPLE
					half3 ray = i.rayDir.xyz;
					half y = ray.y / SKY_GROUND_THRESHOLD;
				#else
					half y = i.skyGroundFactor;
				#endif

				half4 tex = texCUBE (_Tex, i.texcoord);
				half3 c = DecodeHDR (tex, _Tex_HDR);
				c = c * _Tint.rgb * unity_ColorSpaceDouble.rgb;
				c *= _Exposure;

				#if SKYBOX_SUNDISK != SKYBOX_SUNDISK_NONE
					if(y < 0.0)
					{
						c += i.sunColor * calcSunAttenuation(_WorldSpaceLightPos0.xyz, -ray);
					}
				#endif

				return half4(c, 1);
			}
			ENDCG
		}
	}
	Fallback Off
}

実験用の背景としては下図のような画像を使用したところ...

下図のように、太陽の方角に光が描かれました。GIFにつき階調が十分表現できていませんが、実際の見た目はちょっと試した限りでは問題なさそうに見えました。

Answer 2

ご提示のStandard skybox + directional light results in an actual sun. When changing the skybox, the sun is behind the skybox. Is there a workaround to actually see it? : Unity3Dで言及されているように、デフォルトのスカイボックスの太陽はSkybox/Proceduralシェーダーが描いているものであり、Skybox/Cubemapには太陽を描く機能はないでしょう。

Skybox/Cubemapを改造した（というかSkybox/Proceduralの記述をペタペタ貼り付けただけです...やっつけ仕事ですみません）下記のようなSkybox/Cubemap (Sun Disk)を作り、

// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)

Shader "Skybox/Cubemap (Sun Disk)" {
	Properties {
		_Tint ("Tint Color", Color) = (.5, .5, .5, .5)
		[Gamma] _Exposure ("Exposure", Range(0, 8)) = 1.0
		_Rotation ("Rotation", Range(0, 360)) = 0
		[NoScaleOffset] _Tex ("Cubemap	 (HDR)", Cube) = "grey" {}

		[KeywordEnum(None, Simple, High Quality)] _SunDisk ("Sun", Int) = 2
		_SunSize ("Sun Size", Range(0,1)) = 0.04
		_SunSizeConvergence("Sun Size Convergence", Range(1,10)) = 5
		_AtmosphereThickness ("Atmosphere Thickness", Range(0,5)) = 1.0
	}

	SubShader {
		Tags { "Queue"="Background" "RenderType"="Background" "PreviewType"="Skybox" }
		Cull Off ZWrite Off

		Pass {

			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			#pragma target 2.0

			#pragma multi_compile_local _SUNDISK_NONE _SUNDISK_SIMPLE _SUNDISK_HIGH_QUALITY

			#include "UnityCG.cginc"
			#include "Lighting.cginc"

			samplerCUBE _Tex;
			half4 _Tex_HDR;
			half4 _Tint;
			half _Exposure;
			float _Rotation;

			half _SunSize;
			half _SunSizeConvergence;
			half _AtmosphereThickness;

			#if defined(UNITY_COLORSPACE_GAMMA)
				#define GAMMA 2
				#define COLOR_2_GAMMA(color) color
				#define COLOR_2_LINEAR(color) color*color
				#define LINEAR_2_OUTPUT(color) sqrt(color)
			#else
				#define GAMMA 2.2
				// HACK: to get gfx-tests in Gamma mode to agree until UNITY_ACTIVE_COLORSPACE_IS_GAMMA is working properly
				#define COLOR_2_GAMMA(color) ((unity_ColorSpaceDouble.r>2.0) ? pow(color,1.0/GAMMA) : color)
				#define COLOR_2_LINEAR(color) color
				#define LINEAR_2_LINEAR(color) color
			#endif

			// RGB wavelengths
			// .35 (.62=158), .43 (.68=174), .525 (.75=190)
			static const float3 kDefaultScatteringWavelength = float3(.65, .57, .475);
			static const float3 kVariableRangeForScatteringWavelength = float3(.15, .15, .15);

			#define OUTER_RADIUS 1.025
			static const float kOuterRadius = OUTER_RADIUS;
			static const float kOuterRadius2 = OUTER_RADIUS*OUTER_RADIUS;
			static const float kInnerRadius = 1.0;
			static const float kInnerRadius2 = 1.0;

			static const float kCameraHeight = 0.0001;

			#define kRAYLEIGH (lerp(0.0, 0.0025, pow(_AtmosphereThickness,2.5)))	  // Rayleigh constant
			#define kMIE 0.0010				// Mie constant
			#define kSUN_BRIGHTNESS 20.0	// Sun brightness

			#define kMAX_SCATTER 50.0 // Maximum scattering value, to prevent math overflows on Adrenos

			static const half kHDSundiskIntensityFactor = 15.0;
			static const half kSimpleSundiskIntensityFactor = 27.0;

			static const half kSunScale = 400.0 * kSUN_BRIGHTNESS;
			static const float kKmESun = kMIE * kSUN_BRIGHTNESS;
			static const float kKm4PI = kMIE * 4.0 * 3.14159265;
			static const float kScale = 1.0 / (OUTER_RADIUS - 1.0);
			static const float kScaleDepth = 0.25;
			static const float kScaleOverScaleDepth = (1.0 / (OUTER_RADIUS - 1.0)) / 0.25;
			static const float kSamples = 2.0; // THIS IS UNROLLED MANUALLY, DON'T TOUCH

			#define MIE_G (-0.990)
			#define MIE_G2 0.9801

			#define SKY_GROUND_THRESHOLD 0.02

			// sun disk rendering:
			// no sun disk - the fastest option
			#define SKYBOX_SUNDISK_NONE 0
			// simplistic sun disk - without mie phase function
			#define SKYBOX_SUNDISK_SIMPLE 1
			// full calculation - uses mie phase function
			#define SKYBOX_SUNDISK_HQ 2

			// uncomment this line and change SKYBOX_SUNDISK_SIMPLE to override material settings
			// #define SKYBOX_SUNDISK SKYBOX_SUNDISK_SIMPLE

			#ifndef SKYBOX_SUNDISK
				#if defined(_SUNDISK_NONE)
					#define SKYBOX_SUNDISK SKYBOX_SUNDISK_NONE
				#elif defined(_SUNDISK_SIMPLE)
					#define SKYBOX_SUNDISK SKYBOX_SUNDISK_SIMPLE
				#else
					#define SKYBOX_SUNDISK SKYBOX_SUNDISK_HQ
				#endif
			#endif

			#ifndef SKYBOX_COLOR_IN_TARGET_COLOR_SPACE
				#if defined(SHADER_API_MOBILE)
					#define SKYBOX_COLOR_IN_TARGET_COLOR_SPACE 1
				#else
					#define SKYBOX_COLOR_IN_TARGET_COLOR_SPACE 0
				#endif
			#endif

			float3 RotateAroundYInDegrees (float3 vertex, float degrees)
			{
				float alpha = degrees * UNITY_PI / 180.0;
				float sina, cosa;
				sincos(alpha, sina, cosa);
				float2x2 m = float2x2(cosa, -sina, sina, cosa);
				return float3(mul(m, vertex.xz), vertex.y).xzy;
			}

			struct appdata_t {
				float4 vertex : POSITION;
				UNITY_VERTEX_INPUT_INSTANCE_ID
			};

			struct v2f {
				float4 vertex : SV_POSITION;
				float3 texcoord : TEXCOORD0;
				
				#if SKYBOX_SUNDISK == SKYBOX_SUNDISK_HQ
					// for HQ sun disk, we need vertex itself to calculate ray-dir per-pixel
					float3 vertexForSun : TEXCOORD1;
				#elif SKYBOX_SUNDISK == SKYBOX_SUNDISK_SIMPLE
					half3 rayDir : TEXCOORD1;
				#else
					// as we dont need sun disk we need just rayDir.y (sky/ground threshold)
					half skyGroundFactor : TEXCOORD1;
				#endif

				#if SKYBOX_SUNDISK != SKYBOX_SUNDISK_NONE
					half3 sunColor : TEXCOORD3;
				#endif

				UNITY_VERTEX_OUTPUT_STEREO
			};

			float scale(float inCos)
			{
				float x = 1.0 - inCos;
				return 0.25 * exp(-0.00287 + x*(0.459 + x*(3.83 + x*(-6.80 + x*5.25))));
			}

			v2f vert (appdata_t v)
			{
				v2f o;
				UNITY_SETUP_INSTANCE_ID(v);
				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
				float3 rotated = RotateAroundYInDegrees(v.vertex, _Rotation);
				o.vertex = UnityObjectToClipPos(rotated);
				o.texcoord = v.vertex.xyz;

				float3 kSkyTintInGammaSpace = COLOR_2_GAMMA(_Tint); // convert tint from Linear back to Gamma
				float3 kScatteringWavelength = lerp (
					kDefaultScatteringWavelength-kVariableRangeForScatteringWavelength,
					kDefaultScatteringWavelength+kVariableRangeForScatteringWavelength,
					half3(1,1,1) - kSkyTintInGammaSpace); // using Tint in sRGB gamma allows for more visually linear interpolation and to keep (.5) at (128, gray in sRGB) point
				float3 kInvWavelength = 1.0 / pow(kScatteringWavelength, 4);

				float kKrESun = kRAYLEIGH * kSUN_BRIGHTNESS;
				float kKr4PI = kRAYLEIGH * 4.0 * 3.14159265;

				float3 cameraPos = float3(0,kInnerRadius + kCameraHeight,0);	// The camera's current position

				float3 eyeRay = normalize(mul((float3x3)unity_ObjectToWorld, v.vertex.xyz));

(コードの途中ですが、長すぎて別回答に分断します...パート2へ続く)

Comments

[hehebeb]

回答ありがとうございます！
本当に助かりました！太陽を表示するのにもこれほどのコードが必要なのですね...

勉強になりました。これからもよろしくお願いいたしますmm

[Bongo]

実際のところ、光源の方角に太陽っぽい円を描くだけならもっとシンプルにできると思います。
Skybox/Proceduralの場合は大気散乱をシミュレートして空の色を決める仕掛けになっており（光源の角度が水平に近づくと夕焼けのように空がオレンジ色になったりしますよね）、コードがだいぶ複雑になっているようです。せっかくなのでSkybox/Proceduralと同じような品質の太陽を描けた方がいいかな...と思ってSkybox/Proceduralのコードを流用することにしたのですが、いざやってみると太陽を描く部分も散乱の計算過程に密接に関連していたため、結局ほとんどのコードを写し込むことになってしまいました...