言語: 日本語
  • C#
  • JS
  • Boo

スクリプト言語

お好みのスクリプト言語を選択すると、サンプルコードがその言語で表示されます。

LightProbes.coefficients

Suggest a change

Success!

Thank you for helping us improve the quality of Unity Documentation. Although we cannot accept all submissions, we do read each suggested change from our users and will make updates where applicable.

Close

Sumbission failed

For some reason your suggested change could not be submitted. Please try again in a few minutes. And thank you for taking the time to help us improve the quality of Unity Documentation.

Close

Cancel

public var coefficients: float[];
public float[] coefficients;
public coefficients as float[]

Description

Coefficients of the baked light probes. The coefficients represent a 3-band RGB spherical harmonics probe, with a total of 27 floats per light probe, laid out: rgbrgbrgb...

	// Create a copy of the LightProbes object, otherwise writing to coefficients would permanently change the asset itself.
	LightmapSettings.lightProbes = Instantiate(LightmapSettings.lightProbes) as LightProbes;
using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Example() {
        LightmapSettings.lightProbes = Instantiate(LightmapSettings.lightProbes) as LightProbes;
    }
}
import UnityEngine
import System.Collections

public class ExampleClass(MonoBehaviour):

	def Example() as void:
		LightmapSettings.lightProbes = (Instantiate(LightmapSettings.lightProbes) as LightProbes)

	var ambient:Color;
	var lights:Light[];

	// On start, this script will add the contribution of the ambient light and all lights assigned to the array to all baked probes.
	function Start () {
		// Create a copy of the LightProbes object, otherwise writing to coefficients would permanently change the asset itself.
		LightmapSettings.lightProbes = Instantiate(LightmapSettings.lightProbes) as LightProbes;
	    
		var coefficients = LightmapSettings.lightProbes.coefficients;
		var coefficientsPerProbe = 27;
		var probeCount = LightmapSettings.lightProbes.count;
		var probePositions = LightmapSettings.lightProbes.positions;
		var i = 0;
	    
		// Add ambient light to all the probes
		for (i = 0; i < probeCount; i++)
			AddSHAmbientLight(ambient, coefficients, i * coefficientsPerProbe);
	    	
		// Add directional and point lights' contribution to all the probes
		for (var l:Light in lights) {
			if (l.type == LightType.Directional){
				for (i = 0; i < probeCount; i++)
					AddSHDirectionalLight(l.color, -l.transform.forward, l.intensity, coefficients, i * coefficientsPerProbe);
			}
			else if (l.type == LightType.Point){
				for (i = 0; i < probeCount; i++)
					AddSHPointLight(l.color, l.transform.position, l.range, l.intensity, coefficients, i * coefficientsPerProbe, probePositions[i]);
			}
		}

		LightmapSettings.lightProbes.coefficients = coefficients;
	}

	function AddSHAmbientLight (color : Color, coefficients : float[], index : int) {
		var k2SqrtPI = 3.54490770181103205459633496668229f; // 2*sqrt(kPI)
		coefficients[index + 0] += color.r * k2SqrtPI;
		coefficients[index + 1] += color.g * k2SqrtPI;
		coefficients[index + 2] += color.b * k2SqrtPI;
	}

	function AddSHDirectionalLight (color : Color, direction : Vector3, intensity : float, coefficients : float[], index : int) {
		// Read more about Spherical Harmonics in Peter Sloan's "Stupid Spherical Harmonics Tricks"
		var kInv2SqrtPI = 0.28209479177387814347403972578039f; // 1 / (2*sqrt(kPI))
		var kSqrt3Div2SqrtPI = 0.48860251190291992158638462283835f; // sqrt(3) / (2*sqrt(kPI))
		var kSqrt15Div2SqrtPI = 1.0925484305920790705433857058027f; // sqrt(15) / (2*sqrt(kPI))
		var k3Sqrt5Div4SqrtPI = 0.94617469575756001809268107088713f; // 3 * sqrtf(5) / (4*sqrt(kPI))
		var kSqrt15Div4SqrtPI = 0.54627421529603953527169285290135f; // sqrt(15) / (4*sqrt(kPI))
		var kOneThird = 0.3333333333333333333333f; // 1.0/3.0
		var dirFactors = new float[9];
		dirFactors[0] = kInv2SqrtPI;
		dirFactors[1] = -direction.y * kSqrt3Div2SqrtPI;
		dirFactors[2] = direction.z * kSqrt3Div2SqrtPI;
		dirFactors[3] = -direction.x * kSqrt3Div2SqrtPI;
		dirFactors[4] = direction.x * direction.y * kSqrt15Div2SqrtPI;
		dirFactors[5] = -direction.y * direction.z * kSqrt15Div2SqrtPI;
		dirFactors[6] = (direction.z * direction.z - kOneThird) * k3Sqrt5Div4SqrtPI;
		dirFactors[7] = -direction.x * direction.z * kSqrt15Div2SqrtPI;
		dirFactors[8] = (direction.x * direction.x - direction.y * direction.y) * kSqrt15Div4SqrtPI;

		var kNormalization = 2.9567930857315701067858823529412f; // 16*kPI/17
		// Unity doubles the light intensity internally
		intensity *= 2.0f;
		var rscale = color.r * intensity * kNormalization;
		var gscale = color.g * intensity * kNormalization;
		var bscale = color.b * intensity * kNormalization;
		for (var i = 0; i < 9; ++i) {
			var c = dirFactors[i];
			coefficients[index + 3*i + 0] += c * rscale;
			coefficients[index + 3*i + 1] += c * gscale;
			coefficients[index + 3*i + 2] += c * bscale;
		}
	}

	function AddSHPointLight (color : Color, position : Vector3, range : float, intensity : float, coefficients : float[], index : int, probePosition : Vector3) {
		// From a point of view of a SH probe, point light looks no different than a directional light,
		// just attenuated and coming from the right direction
		var probeToLight = position - probePosition;
		var attenuation = 1.0f / (1.0f + (25.0f * probeToLight.sqrMagnitude / (range * range)));
		AddSHDirectionalLight(color, probeToLight.normalized, intensity*attenuation, coefficients, index);
	}
using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    public Color ambient;
    public Light[] lights;
    void Start() {
        LightmapSettings.lightProbes = Instantiate(LightmapSettings.lightProbes) as LightProbes;
        float[] coefficients = LightmapSettings.lightProbes.coefficients;
        int coefficientsPerProbe = 27;
        int probeCount = LightmapSettings.lightProbes.count;
        Vector3[] probePositions = LightmapSettings.lightProbes.positions;
        int i = 0;
        i = 0;
        while (i < probeCount) {
            AddSHAmbientLight(ambient, coefficients, i * coefficientsPerProbe);
            i++;
        }
        foreach (Light l in lights) {
            if (l.type == LightType.Directional) {
                i = 0;
                while (i < probeCount) {
                    AddSHDirectionalLight(l.color, -l.transform.forward, l.intensity, coefficients, i * coefficientsPerProbe);
                    i++;
                }
            } else
                if (l.type == LightType.Point) {
                    i = 0;
                    while (i < probeCount) {
                        AddSHPointLight(l.color, l.transform.position, l.range, l.intensity, coefficients, i * coefficientsPerProbe, probePositions[i]);
                        i++;
                    }
                }
        }
        LightmapSettings.lightProbes.coefficients = coefficients;
    }
    void AddSHAmbientLight(Color color, float[] coefficients, int index) {
        float k2SqrtPI = 3.54490770181F;
        coefficients[index + 0] += color.r * k2SqrtPI;
        coefficients[index + 1] += color.g * k2SqrtPI;
        coefficients[index + 2] += color.b * k2SqrtPI;
    }
    void AddSHDirectionalLight(Color color, Vector3 direction, float intensity, float[] coefficients, int index) {
        float kInv2SqrtPI = 0.28209479177F;
        float kSqrt3Div2SqrtPI = 0.4886025119F;
        float kSqrt15Div2SqrtPI = 1.09254843059F;
        float k3Sqrt5Div4SqrtPI = 0.94617469576F;
        float kSqrt15Div4SqrtPI = 0.5462742153F;
        float kOneThird = 0.33333333333F;
        float[] dirFactors = new float[9];
        dirFactors[0] = kInv2SqrtPI;
        dirFactors[1] = -direction.y * kSqrt3Div2SqrtPI;
        dirFactors[2] = direction.z * kSqrt3Div2SqrtPI;
        dirFactors[3] = -direction.x * kSqrt3Div2SqrtPI;
        dirFactors[4] = direction.x * direction.y * kSqrt15Div2SqrtPI;
        dirFactors[5] = -direction.y * direction.z * kSqrt15Div2SqrtPI;
        dirFactors[6] = (direction.z * direction.z - kOneThird) * k3Sqrt5Div4SqrtPI;
        dirFactors[7] = -direction.x * direction.z * kSqrt15Div2SqrtPI;
        dirFactors[8] = (direction.x * direction.x - direction.y * direction.y) * kSqrt15Div4SqrtPI;
        float kNormalization = 2.95679308573F;
        intensity *= 2.0F;
        float rscale = color.r * intensity * kNormalization;
        float gscale = color.g * intensity * kNormalization;
        float bscale = color.b * intensity * kNormalization;
        int i = 0;
        while (i < 9) {
            float c = dirFactors[i];
            coefficients[index + 3 * i + 0] += c * rscale;
            coefficients[index + 3 * i + 1] += c * gscale;
            coefficients[index + 3 * i + 2] += c * bscale;
            ++i;
        }
    }
    void AddSHPointLight(Color color, Vector3 position, float range, float intensity, float[] coefficients, int index, Vector3 probePosition) {
        Vector3 probeToLight = position - probePosition;
        float attenuation = 1.0F / (1.0F + 25.0F * probeToLight.sqrMagnitude / range * range);
        AddSHDirectionalLight(color, probeToLight.normalized, intensity * attenuation, coefficients, index);
    }
}
import UnityEngine
import System.Collections

public class ExampleClass(MonoBehaviour):

	public ambient as Color

	public lights as (Light)

	def Start() as void:
		LightmapSettings.lightProbes = (Instantiate(LightmapSettings.lightProbes) as LightProbes)
		coefficients as (float) = LightmapSettings.lightProbes.coefficients
		coefficientsPerProbe as int = 27
		probeCount as int = LightmapSettings.lightProbes.count
		probePositions as (Vector3) = LightmapSettings.lightProbes.positions
		i as int = 0
		i = 0
		while i < probeCount:
			AddSHAmbientLight(ambient, coefficients, (i * coefficientsPerProbe))
			i++
		for l as Light in lights:
			if l.type == LightType.Directional:
				i = 0
				while i < probeCount:
					AddSHDirectionalLight(l.color, -l.transform.forward, l.intensity, coefficients, (i * coefficientsPerProbe))
					i++
			elif l.type == LightType.Point:
				i = 0
				while i < probeCount:
					AddSHPointLight(l.color, l.transform.position, l.range, l.intensity, coefficients, (i * coefficientsPerProbe), probePositions[i])
					i++
		LightmapSettings.lightProbes.coefficients = coefficients

	def AddSHAmbientLight(color as Color, coefficients as (float), index as int) as void:
		k2SqrtPI as float = 3.54490770181F
		coefficients[(index + 0)] += (color.r * k2SqrtPI)
		coefficients[(index + 1)] += (color.g * k2SqrtPI)
		coefficients[(index + 2)] += (color.b * k2SqrtPI)

	def AddSHDirectionalLight(color as Color, direction as Vector3, intensity as float, coefficients as (float), index as int) as void:
		kInv2SqrtPI as float = 0.28209479177F
		kSqrt3Div2SqrtPI as float = 0.4886025119F
		kSqrt15Div2SqrtPI as float = 1.09254843059F
		k3Sqrt5Div4SqrtPI as float = 0.94617469576F
		kSqrt15Div4SqrtPI as float = 0.5462742153F
		kOneThird as float = 0.33333333333F
		dirFactors as (float) = array[of float](9)
		dirFactors[0] = kInv2SqrtPI
		dirFactors[1] = ((-direction.y) * kSqrt3Div2SqrtPI)
		dirFactors[2] = (direction.z * kSqrt3Div2SqrtPI)
		dirFactors[3] = ((-direction.x) * kSqrt3Div2SqrtPI)
		dirFactors[4] = ((direction.x * direction.y) * kSqrt15Div2SqrtPI)
		dirFactors[5] = (((-direction.y) * direction.z) * kSqrt15Div2SqrtPI)
		dirFactors[6] = (((direction.z * direction.z) - kOneThird) * k3Sqrt5Div4SqrtPI)
		dirFactors[7] = (((-direction.x) * direction.z) * kSqrt15Div2SqrtPI)
		dirFactors[8] = (((direction.x * direction.x) - (direction.y * direction.y)) * kSqrt15Div4SqrtPI)
		kNormalization as float = 2.95679308573F
		intensity *= 2.0F
		rscale as float = ((color.r * intensity) * kNormalization)
		gscale as float = ((color.g * intensity) * kNormalization)
		bscale as float = ((color.b * intensity) * kNormalization)
		i as int = 0
		while i < 9:
			c as float = dirFactors[i]
			coefficients[((index + (3 * i)) + 0)] += (c * rscale)
			coefficients[((index + (3 * i)) + 1)] += (c * gscale)
			coefficients[((index + (3 * i)) + 2)] += (c * bscale)
			++i

	def AddSHPointLight(color as Color, position as Vector3, range as float, intensity as float, coefficients as (float), index as int, probePosition as Vector3) as void:
		probeToLight as Vector3 = (position - probePosition)
		attenuation as float = (1.0F / (1.0F + ((25.0F * probeToLight.sqrMagnitude) / (range * range))))
		AddSHDirectionalLight(color, probeToLight.normalized, (intensity * attenuation), coefficients, index)