void CalculateCurrentLightsData(FrameLightingData lightingData)
        {
            float playerDepth = feed.CalculatePlayerDepth();

            Light[] foundLights = Light.GetLights(LightType.Directional, layerNum);
            lightingData.directionalLightCount = 0;
            for (int i = 0; i < foundLights.Length && lightingData.directionalLightCount < DIR_LIGHT_ARRAY_MAX; i++)
            {
                if (LightIsAffectingPlayer(foundLights[i], playerDepth))
                {
                    lightingData.directionalLightDirections[lightingData.directionalLightCount] = foundLights[i].transform.forward;
                    lightingData.directionalLightColors[lightingData.directionalLightCount]     = foundLights[i].color * foundLights[i].intensity * directionalLightFactor;
                    lightingData.directionalLightCount++;
                }
            }

            foundLights = Light.GetLights(LightType.Point, layerNum);
            lightingData.pointLightCount = 0;
            for (int i = 0; i < foundLights.Length && lightingData.pointLightCount < POINT_LIGHT_ARRAY_MAX; i++)
            {
                if (LightIsAffectingPlayer(foundLights[i], playerDepth))
                {
                    lightingData.pointLightPositions[lightingData.pointLightCount]   = foundLights[i].transform.position;
                    lightingData.pointLightPositions[lightingData.pointLightCount].w = foundLights[i].range;
                    lightingData.pointLightColors[lightingData.pointLightCount]      = foundLights[i].color * foundLights[i].intensity * pointLightFactor;
                    lightingData.pointLightCount++;
                }
            }

            foundLights = Light.GetLights(LightType.Spot, layerNum);
            lightingData.spotLightCount = 0;
            for (int i = 0; i < foundLights.Length && lightingData.spotLightCount < SPOT_LIGHT_ARRAY_MAX; i++)
            {
                if (LightIsAffectingPlayer(foundLights[i], playerDepth))
                {
                    lightingData.spotLightPositions[lightingData.spotLightCount]    = foundLights[i].transform.position;
                    lightingData.spotLightPositions[lightingData.spotLightCount].w  = foundLights[i].range;
                    lightingData.spotLightDirections[lightingData.spotLightCount]   = foundLights[i].transform.forward;
                    lightingData.spotLightDirections[lightingData.spotLightCount].w = foundLights[i].spotAngle * Mathf.Deg2Rad * 0.5f;
                    lightingData.spotLightColors[lightingData.spotLightCount]       = foundLights[i].color * foundLights[i].intensity * spotLightFactor;
                    lightingData.spotLightCount++;
                }
            }
        }
        private void HandleRenderStarted()
        {
            frames.delayDuration = feed.context.Data.outputMode == MixCastData.OutputMode.Buffered ? feed.context.Data.bufferTime : 0;
            frames.Update();

            if (!feed.context.Data.lightingData.isEnabled ||
                feed.context.Data.lightingData.effectAmount <= 0)
            {
                return;
            }

            feed.blitMaterial.EnableKeyword("LIGHTING_FLAT");

            FrameLightingData nextFrame = PrepareNextFrame();

            CalculateCurrentLightsData(nextFrame);

            FrameLightingData oldFrame = frames.OldestFrameData;

            feed.blitMaterial.SetFloat("_PlayerLightingFactor", feed.context.Data.lightingData.effectAmount);
            feed.blitMaterial.SetFloat("_PlayerLightingBase", feed.context.Data.lightingData.baseLighting);
            feed.blitMaterial.SetFloat("_PlayerLightingPower", feed.context.Data.lightingData.powerMultiplier);

            feed.blitMaterial.SetInt(DIR_LIGHT_ARRAY_SIZE, oldFrame.directionalLightCount);
            feed.blitMaterial.SetVectorArray(DIR_LIGHT_DIRECTIONS, oldFrame.directionalLightDirections);
            feed.blitMaterial.SetVectorArray(DIR_LIGHT_COLORS, oldFrame.directionalLightColors);

            feed.blitMaterial.SetInt(POINT_LIGHT_ARRAY_SIZE, oldFrame.pointLightCount);
            feed.blitMaterial.SetVectorArray(POINT_LIGHT_POSITIONS_AND_RANGE, oldFrame.pointLightPositions);
            feed.blitMaterial.SetVectorArray(POINT_LIGHT_COLORS, oldFrame.pointLightColors);

            feed.blitMaterial.SetInt(SPOT_LIGHT_ARRAY_SIZE, oldFrame.spotLightCount);
            feed.blitMaterial.SetVectorArray(SPOT_LIGHT_POSITION_AND_RANGE, oldFrame.spotLightPositions);
            feed.blitMaterial.SetVectorArray(SPOT_LIGHT_DIRECTIONS_AND_ANGLE, oldFrame.spotLightDirections);
            feed.blitMaterial.SetVectorArray(SPOT_LIGHT_COLORS, oldFrame.spotLightColors);
        }
Ejemplo n.º 3
0
        void CalculateCurrentLightsData(FrameLightingData lightingData)
        {
            MixCastCamera cam = MixCastCamera.FindCamera(feed.context);

            if (cam == null || cam.gameCamera == null)
            {
                return;
            }

            float playerDist = feed.CalculatePlayerDistance(cam.gameCamera);

            lightingData.directionalLightCount = 0;
            if (MixCast.ProjectSettings.specifyLightsManually)
            {
                foreach (Light light in MixCastLight.ActiveDirectionalLights)
                {
                    if ((light.cullingMask & (1 << layerNum)) > 0 && LightIsAffectingPlayer(light, cam.gameCamera, playerDist))
                    {
                        lightingData.directionalLightDirections[lightingData.directionalLightCount] = light.transform.forward;
                        lightingData.directionalLightColors[lightingData.directionalLightCount]     = light.color * light.intensity * MixCast.ProjectSettings.directionalLightPower * 0.5f;
                        lightingData.directionalLightCount++;

                        if (lightingData.directionalLightCount == DIR_LIGHT_ARRAY_MAX)
                        {
                            break;
                        }
                    }
                }
            }
            else
            {
                var directionalLights = Light.GetLights(LightType.Directional, layerNum);
                for (int i = 0; i < directionalLights.Length && lightingData.directionalLightCount < DIR_LIGHT_ARRAY_MAX; i++)
                {
                    if (LightIsAffectingPlayer(directionalLights[i], cam.gameCamera, playerDist))
                    {
                        lightingData.directionalLightDirections[lightingData.directionalLightCount] = directionalLights[i].transform.forward;
                        lightingData.directionalLightColors[lightingData.directionalLightCount]     = directionalLights[i].color * directionalLights[i].intensity * MixCast.ProjectSettings.directionalLightPower * 0.5f;
                        lightingData.directionalLightCount++;
                    }
                }
            }


            lightingData.pointLightCount = 0;
            if (MixCast.ProjectSettings.specifyLightsManually)
            {
                foreach (Light light in MixCastLight.ActivePointLights)
                {
                    if ((light.cullingMask & (1 << layerNum)) > 0 && LightIsAffectingPlayer(light, cam.gameCamera, playerDist))
                    {
                        lightingData.pointLightPositions[lightingData.pointLightCount]   = light.transform.position;
                        lightingData.pointLightPositions[lightingData.pointLightCount].w = light.range;
                        lightingData.pointLightColors[lightingData.pointLightCount]      = light.color * light.intensity * MixCast.ProjectSettings.pointLightPower * 0.5f;
                        lightingData.pointLightCount++;

                        if (lightingData.pointLightCount == POINT_LIGHT_ARRAY_MAX)
                        {
                            break;
                        }
                    }
                }
            }
            else
            {
                var pointLights = Light.GetLights(LightType.Point, layerNum);
                for (int i = 0; i < pointLights.Length && lightingData.pointLightCount < POINT_LIGHT_ARRAY_MAX; i++)
                {
                    if (LightIsAffectingPlayer(pointLights[i], cam.gameCamera, playerDist))
                    {
                        lightingData.pointLightPositions[lightingData.pointLightCount]   = pointLights[i].transform.position;
                        lightingData.pointLightPositions[lightingData.pointLightCount].w = pointLights[i].range;
                        lightingData.pointLightColors[lightingData.pointLightCount]      = pointLights[i].color * pointLights[i].intensity * MixCast.ProjectSettings.pointLightPower * 0.5f;
                        lightingData.pointLightCount++;
                    }
                }
            }

            //foundLights = Light.GetLights(LightType.Spot, layerNum);
            //lightingData.spotLightCount = 0;
            //for (int i = 0; i < foundLights.Length && lightingData.spotLightCount < SPOT_LIGHT_ARRAY_MAX; i++)
            //{
            //    if (LightIsAffectingPlayer(foundLights[i], cam.gameCamera, playerDist))
            //    {
            //        lightingData.spotLightPositions[lightingData.spotLightCount] = foundLights[i].transform.position;
            //        lightingData.spotLightPositions[lightingData.spotLightCount].w = foundLights[i].range;
            //        lightingData.spotLightDirections[lightingData.spotLightCount] = foundLights[i].transform.forward;
            //        lightingData.spotLightDirections[lightingData.spotLightCount].w = foundLights[i].spotAngle * Mathf.Deg2Rad * 0.5f;
            //        lightingData.spotLightColors[lightingData.spotLightCount] = foundLights[i].color * foundLights[i].intensity * MixCast.ProjectSettings.spotLightPower * 0.5f;
            //        lightingData.spotLightCount++;
            //    }
            //}
        }