示例#1
0
    public override void OnLightProbesUpdate()
    {
        //update the probe global indices

        Vector3[] probePositions = LightmapSettings.lightProbes.positions;

        // filter the probes to speed up search
        QuickMesh mesh = new QuickMesh(probePositions);

        mesh.Filter(bounds, transform);

        foreach (var modifier in bakedProbeModifiers)
        {
            int   minindex    = -1;
            float mindistance = float.PositiveInfinity;
            for (int i = 0; i < probePositions.Length; i++)
            {
                var distance = (probePositions[i] - modifier.probe).magnitude;
                if (distance < mindistance)
                {
                    minindex    = i;
                    mindistance = distance;
                }
            }

            modifier.globalindex = minindex;
        }
    }
示例#2
0
    public override void UpdateSamples()
    {
        var meshtransform = this.mesh.transform;
        var mesh          = this.mesh.sharedMesh;
        var uvs           = mesh.uv;

        QuickMesh quickmesh = new QuickMesh(mesh, meshtransform);

        quickmesh.Filter(bounds, transform);
        quickmesh.WeldVertices(threshold);
        quickmesh.UpdateNormals();

        superprobes = new List <Vector3>();

        foreach (var item in quickmesh.vertices)
        {
            superprobes.Add(item.position + item.angleWeightedPsuedoNormal * surfaceoffset);
        }

        base.UpdateSamples();
    }
示例#3
0
    public override void UpdateSamples()
    {
        if (controllers == null)
        {
            controllers = new List <LightprobeController>();
        }
        if (controlTextures == null)
        {
            controlTextures = new List <LightprobeTexture>();
        }
        if (bakedProbeModifiers == null)
        {
            bakedProbeModifiers = new List <LightProbeModifier>();
        }

        UpdateTextureControllers();

        var meshtransform = this.mesh.transform;
        var mesh          = this.mesh.sharedMesh;
        var uvs           = mesh.uv;

        QuickMesh quickmesh = new QuickMesh(mesh, meshtransform);

        quickmesh.Filter(bounds, transform);
        quickmesh.UpdateNormals();

        List <Vector3> spawnprobes = new List <Vector3>();
        List <float>   multipliers = new List <float>();

        var activeSubmeshes = controllers.Select(c => c.submesh).Distinct().ToArray();

        foreach (var submesh in activeSubmeshes)
        {
            var controllers = this.controllers.Where(c => c.submesh == submesh).ToList();

            foreach (var triangle in quickmesh.triangles.Where(t => t.submesh == submesh))
            {
                foreach (var controller in controllers)
                {
                    // for each triangle in the mesh, get the barycentric coordinates of the probe spawn point
                    // the 'world' coordinate system is the texture (uv) space

                    // at this stage, the vertex indices match the originals
                    var barycentric = Barycentric(controller.uv, uvs[triangle.vertices[0].index], uvs[triangle.vertices[1].index], uvs[triangle.vertices[2].index]);
                    var spawn       = triangle.vertices[0].position * barycentric.x + triangle.vertices[1].position * barycentric.y + triangle.vertices[2].position * barycentric.z;

                    if (barycentric.x > 0 && barycentric.y > 0 && barycentric.x + barycentric.y < 1)
                    {
                        spawnprobes.Add(spawn + triangle.normal * controller.height);
                        multipliers.Add(controller.multiplier);
                    }
                }
            }
        }

        // remove redundant colocated probes
        QuickMesh probes = new QuickMesh(spawnprobes.ToArray());

        probes.WeldVertices(threshold);

        bakedProbeModifiers.Clear();

        foreach (var item in probes.vertices)
        {
            bakedProbeModifiers.Add(new LightProbeModifier()
            {
                probe  = item.position,
                scalar = multipliers[item.index]
            });
        }

        superprobes = bakedProbeModifiers.Select(x => x.probe).ToList();
        base.UpdateSamples();

        // apply modifiers immediately so we can see the result. any rebaking will change this at design time, but it will be reset in start().
        ApplyLightmapModifiers();
    }